microsoft--mcp-for-beginners/translations/ne/03-GettingStarted/06-http-streaming/README.md

HTTPS स्ट्रीमिङ्ग मोडल कन्टेक्स्ट प्रोटोकल (MCP) सँग

यस अध्यायले मोडल कन्टेक्स्ट प्रोटोकल (MCP) मा HTTPS प्रयोग गरेर सुरक्षित, स्केलेबल, र वास्तविक समय स्ट्रीमिङ्ग लागू गर्ने विस्तृत मार्गदर्शन प्रदान गर्दछ। यसले स्ट्रीमिङ्गको प्रेरणा, उपलब्ध ट्रान्सपोर्ट मेकानिज्महरू, MCP मा स्ट्रीम योग्य HTTP कसरी लागू गर्ने, सुरक्षा सर्वोत्तम अभ्यासहरू, SSE बाट स्थानान्तरण, र तपाईंको आफ्नै स्ट्रीमिङ्ग MCP अनुप्रयोगहरू निर्माण गर्ने व्यावहारिक मार्गदर्शन समेट्छ।

MCP मा ट्रान्सपोर्ट मेकानिज्महरू र स्ट्रीमिङ्ग

यस भागले MCP मा उपलब्ध विभिन्न ट्रान्सपोर्ट मेकानिज्महरू र तिनीहरूको वास्तविक समय संवाद कायम राख्न स्ट्रीमिङ्ग क्षमताहरूलाई सक्षम पार्ने भूमिकालाई अन्वेषण गर्दछ।

ट्रान्सपोर्ट मेकानिज्म भनेको के हो?

एक ट्रान्सपोर्ट मेकानिज्मले कसरी डाटालाई क्लाइन्ट र सर्भरबीच आदान प्रदान गरिन्छ भनेर परिभाषित गर्छ। MCP ले विभिन्न वातावरण र आवश्यकताहरूका लागि उपयुक्त विभिन्न ट्रान्सपोर्ट प्रकारहरू समर्थन गर्दछ:

• stdio: स्ट्यान्डर्ड इनपुट/आउटपुट, स्थानीय र CLI-आधारित उपकरणहरूको लागि उपयुक्त। सरल तर वेब वा क्लाउडका लागि उपयुक्त छैन।
• SSE (सर्भर-सेंट इभेन्ट्स): सर्भरहरूले HTTP मार्फत क्लाइन्टहरूलाई वास्तविक समय अपडेटहरू पठाउन अनुमति दिन्छ। वेब UI हरूका लागि राम्रो, तर स्केलेबिलिटी र लचिलोपनमा सीमित। MCP स्पेसिफिकेसन 2025-06-18 अनुसार, स्वतन्त्र SSE ट्रान्सपोर्टलाई डिप्रिकेट गरिएको छ र "स्ट्रीम योग्य HTTP" ट्रान्सपोर्टले प्रतिस्थापन गरेको छ।
• स्ट्रीम योग्य HTTP: आधुनिक HTTP-आधारित स्ट्रीमिङ्ग ट्रान्सपोर्ट, जसले सूचनाहरू र राम्रो स्केलेबिलिटी समर्थन गर्दछ। अधिकांश उत्पादन र क्लाउड परिस्थितिका लागि सिफारिश गरिएको।

तुलना तालिका

तलको तुलना तालिकाले यी ट्रान्सपोर्ट मेकानिज्महरूबीचको भिन्नता बुझ्न मद्दत गर्दछ:

ट्रान्सपोर्ट	वास्तविक-समय अपडेटहरू	स्ट्रीमिङ्ग	स्केलेबिलिटी	प्रयोग केस
stdio	छैन	छैन	कम	स्थानीय CLI उपकरणहरू
SSE	छ	छ	मध्यम	वेब, वास्तविक-समय अपडेटहरू
स्ट्रीम योग्य HTTP	छ	छ	उच्च	क्लाउड, बहु-क्लाइन्ट

टिप: उपयुक्त ट्रान्सपोर्ट छनोटले प्रदर्शन, स्केलेबिलिटी, र प्रयोगकर्ता अनुभवमा प्रभाव पार्छ। आधुनिक, स्केलेबल र क्लाउड-तयार अनुप्रयोगहरूको लागि स्ट्रीम योग्य HTTP सिफारिस गरिन्छ।

अघिल्लो अध्यायहरूमा देखाइएको stdio र SSE ट्रान्सपोर्टहरू र यस अध्यायमा समेटिएको स्ट्रीम योग्य HTTP ट्रान्सपोर्टमा ध्यान दिनुहोस्।

स्ट्रीमिङ्ग: अवधारणाहरू र प्रेरणा

स्ट्रीमिङ्गका आधारभूत अवधारणाहरू र प्रेरणाहरू बुझ्नु प्रभावकारी वास्तविक-समय सञ्चार प्रणालीहरू लागू गर्न आवश्यक छ।

स्ट्रीमिङ्ग भनेको नेटवर्क प्रोग्रामिङ्गमा यस्तो प्रविधि हो जसले पूर्ण जवाफ तयार हुन कुर्नुको सट्टा डाटा साना, व्यवस्थापनयोग्य टुक्राहरूमा वा इभेन्टहरूको शृंखलाका रूपमा पठाउन र प्राप्त गर्न अनुमति दिन्छ। यो विशेषगरी उपयुक्त छ:

• ठूला फाइलहरू वा डाटासेटहरूका लागि।
• वास्तविक समय अपडेटहरू (जस्तै, च्याट, प्रगति पट्टीहरू)।
• दीर्घकालीन गणनाहरू जहाँ प्रयोगकर्तालाई सूचित राख्न चाहिन्छ।

यहाँ स्ट्रीमिङ्गको उच्च स्तरका कुरा छन्:

• डाटा क्रमिक रूपमा प्रदान गरिन्छ, एकै पटक होइन।
• क्लाइन्टले डाटा आएको जति नै थाहा पाउँछ।
• अपेक्षित ढिलाइ कम गर्छ र उपयोगकर्ता अनुभव सुधार्छ।

किन स्ट्रीमिङ्ग प्रयोग गर्ने?

स्ट्रीमिङ्ग प्रयोग गर्ने कारणहरू यस्ता छन्:

• प्रयोगकर्ताले तुरुन्त प्रतिक्रिया पाउँछन्, अन्त्यमा मात्रै होइन।
• वास्तविक-समय अनुप्रयोगहरू र प्रतिक्रियाशील UI हरू सक्षम पार्दछ।
• नेटवर्क र कम्प्युट स्रोतहरूको अधिक दक्ष प्रयोग हुन सक्छ।

सरल उदाहरण: HTTP स्ट्रीमिङ्ग सर्भर र क्लाइन्ट

यहाँ एउटा सरल उदाहरण छ जहाँ स्ट्रीमिङ्ग कसरी लागू गरिन्छ:

Python

सर्भर (Python, FastAPI र StreamingResponse प्रयोग गरेर):

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import time

app = FastAPI()

async def event_stream():
    for i in range(1, 6):
        yield f"data: Message {i}\n\n"
        time.sleep(1)

@app.get("/stream")
def stream():
    return StreamingResponse(event_stream(), media_type="text/event-stream")

क्लाइन्ट (Python, requests प्रयोग गरेर):

import requests

with requests.get("http://localhost:8000/stream", stream=True) as r:
    for line in r.iter_lines():
        if line:
            print(line.decode())

यस उदाहरणले देखाउँछ कि सर्भरले सन्देशहरूको श्रृंखला क्लाइन्टलाई पठाउछ जति ती तयार हुन्छन्, सबै सन्देश तयार हुन कुर्नुको सट्टा।

यो कसरी काम गर्छ:

• सर्भर प्रत्येक सन्देश तयार हुँदा नै पठाउँछ।
• क्लाइन्ट आएको प्रत्येक टुक्रा प्राप्त गरी प्रिन्ट गर्छ।

आवश्यकताहरू:

• सर्भरले स्ट्रीमिङ्ग प्रतिक्रिया (जस्तै StreamingResponse FastAPI मा) प्रयोग गर्नुपर्छ।
• क्लाइन्टले प्रतिक्रिया स्ट्रीमको रूपमा प्रक्रिया गर्नुपर्छ (stream=True requests मा)।
• Content-Type प्रायः text/event-stream वा application/octet-stream हुन्छ।

Java

सर्भर (Java, Spring Boot र Server-Sent Events प्रयोग गरेर):

@RestController
public class CalculatorController {

    @GetMapping(value = "/calculate", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> calculate(@RequestParam double a,
                                                   @RequestParam double b,
                                                   @RequestParam String op) {
        
        double result;
        switch (op) {
            case "add": result = a + b; break;
            case "sub": result = a - b; break;
            case "mul": result = a * b; break;
            case "div": result = b != 0 ? a / b : Double.NaN; break;
            default: result = Double.NaN;
        }

        return Flux.<ServerSentEvent<String>>just(
                    ServerSentEvent.<String>builder()
                        .event("info")
                        .data("Calculating: " + a + " " + op + " " + b)
                        .build(),
                    ServerSentEvent.<String>builder()
                        .event("result")
                        .data(String.valueOf(result))
                        .build()
                )
                .delayElements(Duration.ofSeconds(1));
    }
}

क्लाइन्ट (Java, Spring WebFlux WebClient प्रयोग गरेर):

@SpringBootApplication
public class CalculatorClientApplication implements CommandLineRunner {

    private final WebClient client = WebClient.builder()
            .baseUrl("http://localhost:8080")
            .build();

    @Override
    public void run(String... args) {
        client.get()
                .uri(uriBuilder -> uriBuilder
                        .path("/calculate")
                        .queryParam("a", 7)
                        .queryParam("b", 5)
                        .queryParam("op", "mul")
                        .build())
                .accept(MediaType.TEXT_EVENT_STREAM)
                .retrieve()
                .bodyToFlux(String.class)
                .doOnNext(System.out::println)
                .blockLast();
    }
}

Java कार्यान्वयन नोटहरू:

• Spring Boot को प्रतिक्रियाशील स्ट्याक Flux सँग स्ट्रीमिङ्गका लागि प्रयोग।
• ServerSentEvent ले संरचित इभेन्ट स्ट्रीमिङ्ग र इभेन्ट प्रकारहरू प्रदान गर्छ।
• WebClient को bodyToFlux() ले प्रतिक्रियाशील स्ट्रीमिङ्ग उपभोग सक्षम पार्दछ।
• delayElements() ले इभेन्टहरू बीच प्रक्रिया समय सिमुलेट गर्दछ।
• इभेन्टहरूले क्लाइन्टलाई राम्रोसँग सम्हाल्नका लागि प्रकारहरू (info, result) समावेश गर्न सक्छन्।

तुलना: क्लासिक स्ट्रीमिङ्ग बनाम MCP स्ट्रीमिङ्ग

कसरी क्लासिक तरिकाले स्ट्रीमिङ्ग काम गर्छ र MCP मा कसरी काम गर्छ भन्ने भिन्नता यसरी देखाउन सकिन्छ:

विशेषता	क्लासिक HTTP स्ट्रीमिङ्ग	MCP स्ट्रीमिङ्ग (सूचनाहरू)
मुख्य प्रतिक्रिया	टुक्रा टुक्रामा पठाइन्छ	एकै पटक, अन्तमा पठाइन्छ
प्रगति अपडेटहरू	डाटा टुक्राका रूपमा पठाइन्छ	सूचनाहरूका रूपमा पठाइन्छ
क्लाइन्ट आवश्यकता	स्ट्रीम प्रक्रिया गर्नुपर्छ	सन्देश ह्यान्डलर कार्यान्वयन गर्नुपर्छ
प्रयोग केस	ठूला फाइलहरू, AI टोकन स्ट्रीम	प्रगति, लग, वास्तविक-समय प्रतिक्रिया

प्रमुख भिन्नताहरू

थप केही प्रमुख भिन्नताहरू:

• सञ्चार ढाँचा:

  • क्लासिक HTTP स्ट्रीमिङ्ग: सजिलो टुक्रा ट्रान्सफर एन्कोडिङ्ग प्रयोग गरेर डाटा टुक्रा पठाउँछ
  • MCP स्ट्रीमिङ्ग: JSON-RPC प्रोटोकलसहित संरचित सूचना प्रणाली प्रयोग गर्छ

• सन्देश ढाँचा:

  • क्लासिक HTTP: नयाँ लाइनसहितको सादा पाठ टुक्रा
  • MCP: मेटाडाटासहित संरचित LoggingMessageNotification वस्तुहरू

• क्लाइन्ट कार्यान्वयन:

  • क्लासिक HTTP: स्ट्रीमिङ्ग प्रतिक्रिया प्रक्रिया गर्ने सरल क्लाइन्ट
  • MCP: भिन्न प्रकारका सन्देशहरू प्रक्रिया गर्न सन्देश ह्यान्डलर सहित जटिल क्लाइन्ट

• प्रगति अपडेटहरू:

  • क्लासिक HTTP: प्रगति मुख्य प्रतिक्रिया स्ट्रिमको हिस्सा
  • MCP: मुख्य प्रतिक्रिया अन्तमा आउँछ, प्रगति छुट्टै सूचनाका रूपमा पठाइन्छ

सिफारिसहरू

क्लासिक स्ट्रीमिङ्ग (जस्तै हामीले /stream इन्डप्वइन्ट प्रयोग गरेर देखायौं) वा MCP मार्फत स्ट्रीमिङ्ग छनोट गर्दा केहि सिफारिसहरू छन्:

• सरल स्ट्रीमिङ्ग आवश्यकताको लागि: क्लासिक HTTP स्ट्रीमिङ्ग लागू गर्न सजिलो र आधारभूत स्ट्रीमिङ्ग आवश्यकताका लागि पर्याप्त छ।

• जटिल, अन्तरक्रियात्मक अनुप्रयोगहरूको लागि: MCP स्ट्रीमिङ्गले सूचनाहरू र अन्तिम परिणाम बिच विभाजनसँगै समृद्ध मेटाडाटा सहित संरचित दृष्टिकोण दिन्छ।

• AI अनुप्रयोगहरूको लागि: लामो समय चल्ने AI कार्यहरूमा प्रगति सूचना दिन MCP को सूचना प्रणाली विशेष उपयोगी हुन्छ।

MCP मा स्ट्रीमिङ्ग

अबसम्म तपाईंले क्लासिक र MCP स्ट्रीमिङ्गबीचका सिफारिस र तुलना देख्नुभएको छ। अब MCP मा स्ट्रीमिङ्ग कसरी उपयोग गर्ने भनेर विस्तृत जानौँ।

MCP फ्रेमवर्कभित्र स्ट्रीमिङ्ग कसरी काम गर्छ भनी बुझ्नु आवश्यक छ ताकि प्रयोगकर्तालाई दीर्घकालीन अपरेशनको क्रममा वास्तविक-समय प्रतिक्रिया प्रदान गर्ने प्रतिक्रियाशील अनुप्रयोगहरू निर्माण गर्न सकियोस।

MCP मा, मुख्य प्रतिक्रिया टुक्रा गरेर पठाउने होइन, तर टूलले अनुरोध प्रोसेस गर्दा क्लाइन्टलाई सूचनाहरू पठाउने हो। यी सूचनाहरूमा प्रगति अपडेट, लगहरू, वा अन्य इभेन्टहरू समावेश हुन सक्छन्।

यसले कसरी काम गर्छ

मुख्य परिणाम अझै एकै पटक पठाइन्छ। यद्यपि, प्रोसेसिङ्गको क्रममा छुट्टै सन्देशहरूका रूपमा सूचनाहरू पठाइन्छ र यसैले क्लाइन्टलाई वास्तविक समयमा अपडेट गरिन्छ। क्लाइन्टले यी सूचनाहरू सम्हाल्न र देखाउन सक्षम हुनुपर्छ।

सूचना भनेको के हो?

हामीले "सूचना" भनेका थियौं, MCP सन्दर्भमा यसको अर्थ के हो?

सूचना भनेको सर्भरबाट क्लाइन्टमा पठाइने सन्देश हो जसले दीर्घकालीन अपरेसनको क्रममा प्रगति, स्थिति वा अन्य इभेन्टहरूको बारेमा जानकारी दिन्छ। सूचनाले पारदर्शिता र प्रयोगकर्ता अनुभव सुधार्छ।

उदाहरणका लागि, क्लाइन्टले सर्भरसँग प्रारम्भिक ह्याण्डशेक भएपछि सूचना पठाउनुपर्छ।

सूचना JSON सन्देशका रूपमा यसरी देखिन्छ:

{
  jsonrpc: "2.0";
  method: string;
  params?: {
    [key: string]: unknown;
  };
}

सूचनाहरू MCP मा "Logging" भनिने विषयसमूहसँग सम्बन्धित छन्।

लगिङ्ग काम गर्नका लागि, सर्भरले यसलाई सुविधा/क्षमता रूपमा यसरी सक्षम पार्नुपर्छ:

{
  "capabilities": {
    "logging": {}
  }
}

Note

प्रयोग गरिएको SDK मा निर्भर गर्दै, लगिङ्ग पूर्वनिर्धारित रूपमा सक्षम हुन सक्छ, वा तपाईँले सर्भर कन्फिगरेसनमा प्रस्ट रूपमा यसलाई सक्षम पार्नुपर्ने हुन सक्छ।

विभिन्न प्रकारका सूचनाहरू छन्:

स्तर	विवरण	उदाहरण प्रयोग केस
debug	विस्तृत डिबग जानकारी	फङ्सनको प्रवेश/निर्गमन बिन्दुहरू
info	सामान्य जानकारीपूर्ण सन्देशहरू	अपरेशन प्रगति अपडेटहरू
notice	सामान्य तर महत्वपूर्ण घटनाहरू	कन्फिगरेसन परिवर्तनहरू
warning	चेतावनी अवस्थाहरू	अव्यवस्थित फिचर प्रयोग
error	त्रुटि अवस्थाहरू	अपरेशन असफलता
critical	गम्भीर अवस्थाहरू	प्रणाली घटक असफलता
alert	तत्काल कारबाही गर्नुपर्छ	डाटा भंग कम्पनमा
emergency	प्रणाली अनुपयोग्य	पूर्ण प्रणाली असफलता

MCP मा सूचना कार्यान्वयन

MCP मा सूचना कार्यान्वयन गर्न, तपाईंले सर्भर र क्लाइन्ट दुवै पक्षलाई वास्तविक-समय अपडेटहरू सम्हाल्न सेटअप गर्नुपर्छ। यसले तपाईंको अनुप्रयोगलाई दीर्घकालीन अपरेशनका दौरान प्रयोगकर्तालाई तुरुन्त प्रतिक्रिया दिन सक्षम बनाउँछ।

सर्भर-पक्ष: सूचना पठाउने

सर्भर पक्षबाट सुरु गरौं। MCP मा, तपाईंले यस्ता उपकरणहरू परिभाषित गर्नुहुन्छ जुन अनुरोध प्रोसेस गर्दा सूचनाहरू पठाउन सक्छन्। सर्भरले सन्देशहरू पठाउन प्रायः ctx सन्दर्भ वस्तु प्रयोग गर्छ।

Python

@mcp.tool(description="A tool that sends progress notifications")
async def process_files(message: str, ctx: Context) -> TextContent:
    await ctx.info("Processing file 1/3...")
    await ctx.info("Processing file 2/3...")
    await ctx.info("Processing file 3/3...")
    return TextContent(type="text", text=f"Done: {message}")

अघिल्लो उदाहरणमा, process_files टूलले प्रत्येक फाइल प्रोसेस गर्दा क्लाइन्टलाई तीनवटा सूचनाहरू पठाउँछ। ctx.info() मेथडले जानकारीपूर्ण सन्देशहरू पठाउन प्रयोग गरिएको छ।

थप रूपमा, सूचनाहरू सक्षम गर्न, तपाईंको सर्भरले स्ट्रीमिङ्ग ट्रान्सपोर्ट (जस्तै streamable-http) प्रयोग गरेको हुनुपर्छ र तपाईंको क्लाइन्टले सूचनाहरू प्रोसेस गर्न सन्देश ह्यान्डलर कार्यान्वयन गरेको हुनुपर्छ। यसरी streamable-http ट्रान्सपोर्ट प्रयोग गर्न सर्भर सेटअप गर्न सकिन्छ:

mcp.run(transport="streamable-http")

.NET

[Tool("A tool that sends progress notifications")]
public async Task<TextContent> ProcessFiles(string message, ToolContext ctx)
{
    await ctx.Info("Processing file 1/3...");
    await ctx.Info("Processing file 2/3...");
    await ctx.Info("Processing file 3/3...");
    return new TextContent
    {
        Type = "text",
        Text = $"Done: {message}"
    };
}

यस .NET उदाहरणमा, ProcessFiles टूल Tool एट्रिब्युटले सजाइएको छ र प्रत्येक फाइल प्रोसेस गर्दा क्लाइन्टलाई तीनवटा सूचनाहरू पठाउँछ। ctx.Info() मेथडले जानकारी सन्देशहरू पठाउँछ।

तपाईंको .NET MCP सर्भरमा सूचनाहरू सक्षम गर्न, स्ट्रीमिङ्ग ट्रान्सपोर्ट प्रयोग गरिरहेको हुनुपर्छ:

var builder = McpBuilder.Create();
await builder
    .UseStreamableHttp() // Enable streamable HTTP transport
    .Build()
    .RunAsync();

क्लाइन्ट-पक्ष: सूचना प्राप्त गर्ने

क्लाइन्टले सन्देश ह्यान्डलर कार्यान्वयन गर्नुपर्छ जसले आउँदै गरेका सूचनाहरूलाई प्रक्रिया गरी देखाउन सक्छ।

Python

async def message_handler(message):
    if isinstance(message, types.ServerNotification):
        print("NOTIFICATION:", message)
    else:
        print("SERVER MESSAGE:", message)

async with ClientSession(
   read_stream, 
   write_stream,
   logging_callback=logging_collector,
   message_handler=message_handler,
) as session:

अघिल्लो कोडमा, message_handler फङ्सनले आएको सन्देश सूचना हो कि हो भनि जाँच गर्छ। यदि हो भने, सूचना प्रिन्ट गर्छ; अन्यथा सामान्य सर्भर सन्देशको रूपमा प्रोसेस गर्छ। ClientSession सन्देश ह्यान्डलरसहित आरम्भ गरिएको छ जसले प्राप्त सूचनाहरू सम्हाल्छ।

.NET

// Define a message handler
void MessageHandler(IJsonRpcMessage message)
{
    if (message is ServerNotification notification)
    {
        Console.WriteLine($"NOTIFICATION: {notification}");
    }
    else
    {
        Console.WriteLine($"SERVER MESSAGE: {message}");
    }
}

// Create and use a client session with the message handler
var clientOptions = new ClientSessionOptions
{
    MessageHandler = MessageHandler,
    LoggingCallback = (level, message) => Console.WriteLine($"[{level}] {message}")
};

using var client = new ClientSession(readStream, writeStream, clientOptions);
await client.InitializeAsync();

// Now the client will process notifications through the MessageHandler

यस .NET उदाहरणमा, MessageHandler फङ्सनले आएको सन्देश सूचना हो कि हो जाँच गर्छ। यदि हो भने, सूचना प्रिन्ट गर्छ; अन्यथा सामान्य सर्भर सन्देशको रूपमा प्रोसेस गर्छ। ClientSession ClientSessionOptions मार्फत सन्देश ह्यान्डलरसहित आरम्भ गरिएको छ।

सूचनाहरू सक्षम गर्न, तपाईंको सर्भरले स्ट्रीमिङ्ग ट्रान्सपोर्ट (जस्तै streamable-http) प्रयोग गरेको हुनुपर्छ र क्लाइन्टले सूचनाहरू प्रोसेस गर्ने सन्देश ह्यान्डलर कार्यान्वयन गरेको हुनुपर्छ।

प्रगति सूचनाहरू र परिदृश्यहरू

यस भागले MCP मा प्रगति सूचनाको अवधारणा, यसको महत्त्व, र Streamable HTTP प्रयोग गरेर यसलाई कसरी कार्यान्वयन गर्ने बताउँछ। तपाईं दुखाइ प्रज्ञापनका लागि व्यावहारिक अभ्यास पनि पाउनुहुनेछ।

प्रगति सूचनाहरू दीर्घकालीन कार्यहरूका क्रममा सर्भरबाट क्लाइन्टलाई पठाइने वास्तविक-समय सन्देशहरू हुन्। पूरै प्रक्रिया सम्पन्न हुन कुर्नुको सट्टा, सर्भरले क्लाइन्टलाई हालको स्थिति अपडेट गरिरहन्छ। यसले पारदर्शिता, प्रयोगकर्ता अनुभव सुधार्छ र डिबगिङ्ग सजिलो बनाउँछ।

उदाहरण:

"Processing document 1/10"
"Processing document 2/10"
...
"Processing complete!"

किन प्रगति सूचनाहरू प्रयोग गर्ने?

प्रगति सूचनाहरू केही कारणले महत्त्वपूर्ण छन्:

• राम्रो प्रयोगकर्ता अनुभव: काम हुँदै गर्दा अपडेटहरू देखिन्छन्, अन्त्यमा मात्र होइन।
• वास्तविक-समय प्रतिक्रिया: क्लाइन्टले प्रगति पट्टी वा लग देखाउन सक्छ, जसले अनुप्रयोगलाई प्रतिक्रियाशील बनाउँछ।
• डिबगिङ्ग र अनुगमन सजिलो: विकासकर्ता र प्रयोगकर्ताले प्रक्रिया कहाँ सुस्त छ वा अड्किएको छ सजिलै देख्न सक्छन्।

प्रगति सूचनाहरू कसरी लागू गर्ने

MCP मा प्रगति सूचनाहरू यसरी लागू गर्न सकिन्छ:

• सर्भरमा: प्रत्येक वस्तु प्रोसेस गर्दा ctx.info() वा ctx.log() प्रयोग गरी सूचना पठाउनुहोस्। यसले मुख्य परिणाम तयार हुनु अघि क्लाइन्टलाई सन्देश पठाउँछ।
• क्लाइन्टमा: सन्देश ह्यान्डलर कार्यान्वयन गर्नुहोस् जसले सूचनाहरू सुन्दै र देखाउने काम गर्छ। यो ह्यान्डलर सूचनाहरू र अन्तिम परिणाम अलग गर्छ।

सर्भर उदाहरण:

Python

@mcp.tool(description="A tool that sends progress notifications")
async def process_files(message: str, ctx: Context) -> TextContent:
    for i in range(1, 11):
        await ctx.info(f"Processing document {i}/10")
    await ctx.info("Processing complete!")
    return TextContent(type="text", text=f"Done: {message}")

क्लाइन्ट उदाहरण:

Python

async def message_handler(message):
    if isinstance(message, types.ServerNotification):
        print("NOTIFICATION:", message)
    else:
        print("SERVER MESSAGE:", message)

सुरक्षा विचारहरू

जब HTTP-आधारित ट्रान्सपोर्टहरूसँग MCP सर्भरहरू निर्माण गरिन्छ, सुरक्षा सबैभन्दा महत्त्वपूर्ण विषय बन्छ जसले धेरै आक्रमण भेक्टर र संरक्षण उपायहरूमा सावधानी आवश्यक पर्दछ।

अवलोकन

HTTP मार्फत MCP सर्भरहरू सार्वजनिक गर्दा सुरक्षा अत्यन्त महत्वपूर्ण हुन्छ। स्ट्रीम योग्य HTTP ले नयाँ आक्रमण सतहहरू सिर्जना गर्दछ र सावधानीपूर्वक कन्फिगरेसन आवश्यक छ।

प्रमुख बुँदाहरू

• Origin हेडर प्रमाणीकरण: DNS रिबाइन्डिङ आक्रमणबाट बच्न सँधै Origin हेडर प्रमाणीकरण गर्नुहोस्।
• Localhost बाइन्डिङ: स्थानीय विकासको लागि, सर्भरहरूलाई localhost मा बाँध्नुहोस् ताकि तिनीहरू सार्वजनिक इन्टरनेटमा नखुलुन्।
• प्रमाणीकरण: उत्पादन वातावरणका लागि प्रमाणीकरण लागू गर्नुहोस् (जस्तै, API कुञ्जीहरू, OAuth)।
• CORS: पहुँच सीमित गर्न क्रस-ओरिजिन रिसोर्स शेयरिङ्ग (CORS) नीतिहरू कन्फिगर गर्नुहोस्।
• HTTPS: उत्पादनमा ट्राफिक इन्क्रिप्ट गर्न HTTPS प्रयोग गर्नुहोस्।

सर्वोत्तम अभ्यासहरू

• कुनै पनि आउने अनुरोधलाई प्रमाणीकरण बिना विश्वास नगर्नुहोस्।
• सबै पहुँच र त्रुटिहरू लग र अनुगमन गर्नुहोस्।
• सुरक्षा कमजोरीहरू रोक्न नियमित रूपमा निर्भरता अपडेट गर्नुहोस्।

चुनौतीहरू

• विकासको सहजतासँग सुरक्षा सन्तुलन
• विभिन्न क्लाइन्ट वातावरणहरूसँग अनुकूलता सुनिश्चित गर्नु

SSE बाट Streamable HTTP मा अपग्रेड गर्ने

हाल Server-Sent Events (SSE) प्रयोग गरिरहेका अनुप्रयोगहरूको लागि, Streamable HTTP मा स्थानान्तरणले तपाईँको MCP कार्यान्वयनहरूका लागि उन्नत क्षमता र दीर्घकालीन स्थायित्व प्रदान गर्दछ।

किन अपग्रेड गर्ने?

SSE बाट Streamable HTTP मा अपग्रेड गर्ने दुइटा बलियो कारणहरू छन्:

• Streamable HTTP ले SSE भन्दा राम्रो स्केलेबिलिटी, अनुकूलता, र समृद्ध सूचना समर्थन प्रदान गर्दछ।
• यो नयाँ MCP अनुप्रयोगहरूको लागि सिफारिस गरिएको ट्रान्सपोर्ट हो।

माइग्रेशनका चरणहरू

तपाईंको MCP अनुप्रयोगहरूमा SSE बाट Streamable HTTP मा कसरी माइग्रेट गर्ने:

• सर्भर कोड अपडेट गर्नुहोस् mcp.run() मा transport="streamable-http" प्रयोग गर्न।
• क्लाइन्ट कोड अपडेट गर्नुहोस् SSE क्लाइन्टको सट्टा streamablehttp_client प्रयोग गर्न।
• क्लाइन्टमा सन्देश ह्यान्डलर कार्यान्वयन गर्नुहोस् सूचना प्रसोधन गर्न।
• मौजुदा उपकरणहरू र कार्यप्रवाहहरूसँग अनुकूलता परीक्षण गर्नुहोस्।

अनुकूलता कायम राख्नु

माइग्रेशन प्रक्रियामा मौजुदा SSE क्लाइन्टहरूसँग अनुकूलता कायम राख्न सिफारिस गरिन्छ। यहाँ केही रणनीतिहरू छन्:

• तपाईं SSE र Streamable HTTP दुवै समर्थन गर्न सक्नुहुन्छ, दुवै ट्रान्सपोर्टहरूलाई फरक-फरक अन्त बिन्दुहरूमा चलाएर।
• क्लाइन्टहरूलाई बिस्तारै नयाँ ट्रान्सपोर्टमा माइग्रेट गर्नुहोस्।

चुनौतिहरू

माइग्रेशन क्रममा निम्न चुनौतिहरू याद गर्नुहोस्:

• सबै क्लाइन्टहरू अपडेट गरिएको सुनिश्चित गर्नु
• सूचना वितरणमा फरकहरू सम्हाल्नु

सुरक्षा विचारहरू

कुनै पनि सर्भर कार्यान्वयन गर्दा सुरक्षा शीर्ष प्राथमिकता हुनुपर्छ, विशेष गरी MCP मा Streamable HTTP जस्ता HTTP आधारित ट्रान्सपोर्टहरू प्रयोग गर्दा।

HTTP आधारित ट्रान्सपोर्टहरूसहित MCP सर्भरहरू कार्यान्वयन गर्दा सुरक्षा एक महत्वपूर्ण विषय हो जसले धेरै आक्रमण भेक्टरहरू र सुरक्षा संयन्त्रहरूमा सावधानीपूर्वक ध्यान दिन आवश्यक हुन्छ।

अवलोकन

MCP सर्भरहरू HTTP मार्फत एक्स्पोज गर्दा सुरक्षा अत्यावश्यक हुन्छ। Streamable HTTP नयाँ आक्रमण सतहहरू ल्याउँछ र सावधानीपूर्वक कन्फिगरेसन आवश्यक हुन्छ।

यहाँ केहि मुख्य सुरक्षा विचारहरू छन्:

• अरिजन हेडर प्रमाणीकरण: DNS रिबाइन्डिङ आक्रमण रोक्न Origin हेडर सँधै प्रमाणित गर्नुहोस्।
• लोकलहोस्ट बाँध्ने: स्थानीय विकासका लागि सर्भरहरूलाई localhost मा बाँध्नुहोस् ताकि सार्वजनिक इन्टरनेटमा एक्स्पोज नगरियोस्।
• प्रमाणीकरण: उत्पादन परिनियोजनहरूका लागि प्रमाणीकरण (जस्तै API कुञ्जीहरू, OAuth) लागू गर्नुहोस्।
• CORS: एक्सेस सीमित गर्न Cross-Origin Resource Sharing (CORS) नीतिहरू कन्फिगर गर्नुहोस्।
• HTTPS: ट्राफिक इन्क्रिप्ट गर्न उत्पादनमा HTTPS प्रयोग गर्नुहोस्।

उत्तम अभ्यासहरू

तलका उत्तम अभ्यासहरू MCP स्ट्रिमिङ सर्भरमा सुरक्षा कार्यान्वयन गर्दा पालन गर्नुहोस्:

• बिना प्रमाणीकरण आउने अनुरोधहरूमा विश्वास नगर्नुहोस्।
• सबै पहुँच र त्रुटिहरूलाई लग र अनुगमन गर्नुहोस्।
• सुरक्षा कमजोरीहरूका लागि निर्भरता नियमित रूपमा अपडेट गर्नुहोस्।

चुनौतिहरू

MCP स्ट्रिमिङ सर्भरमा सुरक्षा कार्यान्वयन गर्दा तपाईंलाई यी चुनौतिहरूसँग सामना हुनेछ:

• विकासको सहजतासँग सुरक्षाको सन्तुलन
• विभिन्न क्लाइन्ट वातावरणहरूसँग अनुकूलता सुनिश्चित गर्नु

कार्य: आफ्नो स्ट्रिमिङ MCP अनुप्रयोग बनाउनुहोस्

परिदृश्य: एक MCP सर्भर र क्लाइन्ट बनाउनुहोस् जहाँ सर्भरले वस्तुहरूको सूची (जस्तै फाइलहरू वा कागजातहरू) प्रक्रिया गर्छ र प्रत्येक प्रक्रिया गरिएको वस्तुका लागि सूचना पठाउँछ। क्लाइन्टले प्रत्येक सूचना आइपुगेपछि देखाउनु पर्छ।

चरणहरू:

1. सूची प्रक्रिया गर्ने र प्रत्येक वस्तुका लागि सूचनाहरू पठाउने सर्भर उपकरण कार्यान्वयन गर्नुहोस्।
2. रियल टाइममा सूचना प्रदर्शन गर्न सन्देश ह्यान्डलर सहित क्लाइन्ट कार्यान्वयन गर्नुहोस्।
3. सर्भर र क्लाइन्ट दुवै चलाएर तपाईंको कार्यान्वयन परीक्षण गर्नुहोस् र सूचनाहरूको अवलोकन गर्नुहोस्।

Solution

थप पढ्न र के गर्ने?

MCP स्ट्रिमिङसँग आफ्नो यात्रा जारी राख्न र ज्ञान विस्तार गर्न, यो खण्डले थप स्रोतहरू र उन्नत अनुप्रयोगहरू निर्माणका लागि सुझावहरू प्रदान गर्दछ।

थप पढ्ने

• Microsoft: HTTP Streaming परिचय
• Microsoft: Server-Sent Events (SSE)
• Microsoft: ASP.NET Core मा CORS
• Python requests: Streaming Requests

के गर्ने अब?

• रियल टाइम एनालिटिक्स, च्याट, वा सहकार्यात्मक सम्पादनका लागि स्ट्रिमिङ प्रयोग गर्ने उन्नत MCP उपकरणहरू बनाउन प्रयास गर्नुहोस्।
• स्ट्रिमिङलाई फ्रन्टएन्ड फ्रेमवर्कहरू (React, Vue, आदि) सँग एकीकृत गर्न अन्वेषण गर्नुहोस् ताकि प्रत्यक्ष UI अपडेटहरू गर्न सकियोस्।
• अर्को: VSCode का लागि AI उपकरण किट उपयोग गर्ने

---

अस्वीकरण: यो दस्तावेज़ AI अनुवाद सेवा Co-op Translator प्रयोग गरेर अनुवाद गरिएको हो। हामी सही हुन प्रयास गर्छौं, तर कृपया जानकार हुनुस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छन्। मूल दस्तावेज़ यसको मूल भाषामा आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीका लागि व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न कुनै पनि गलत बुझाइ वा त्रुटिको लागि हामी जिम्मेवार छैनौं।