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

HTTPS سے Model Context Protocol (MCP) کے ساتھ اسٹریمنگ

یہ باب محفوظ، قابل توسیع، اور حقیقی وقت میں اسٹریمنگ کو Model Context Protocol (MCP) کے ذریعے HTTPS کے ساتھ نافذ کرنے کی جامع رہنمائی فراہم کرتا ہے۔ اس میں اسٹریمنگ کی ترغیب، دستیاب ٹرانسپورٹ میکانیزم، MCP میں اسٹریم ایبل HTTP کو نافذ کرنے کا طریقہ، سیکیورٹی کی بہترین عملی تدابیر، SSE سے مائگریشن، اور اپنی خود کی اسٹریمنگ MCP ایپلیکیشنز بنانے کے لیے عملی رہنمائی شامل ہے۔

MCP میں ٹرانسپورٹ میکانیزم اور اسٹریمنگ

اس سیکشن میں MCP میں دستیاب مختلف ٹرانسپورٹ میکانیزمز کا جائزہ لیا جاتا ہے اور یہ حقیقی وقت کے لیے کلائنٹس اور سرورز کے درمیان اسٹریمنگ کی صلاحیتوں کو کیسے ممکن بناتے ہیں۔

ٹرانسپورٹ میکانزم کیا ہے؟

ٹرانسپورٹ میکانزم اس بات کی وضاحت کرتا ہے کہ کلائنٹ اور سرور کے درمیان ڈیٹا کس طرح تبادلہ کیا جاتا ہے۔ MCP مختلف ماحول اور ضروریات کے مطابق مختلف قسم کے ٹرانسپورٹ کو سپورٹ کرتا ہے:

• stdio: سٹینڈرڈ ان پٹ/آؤٹ پٹ، مقامی اور CLI پر مبنی آلات کے لیے مناسب۔ سادہ مگر ویب یا کلاؤڈ کے لیے موزوں نہیں۔
• SSE (سرور-سِینٹ ایونٹس): سرورز کو HTTP کے ذریعے کلائنٹس کو حقیقی وقت میں اپڈیٹس بھیجنے کی اجازت دیتا ہے۔ ویب UI کے لیے اچھا، لیکن اسکیل ایبلٹی اور لچک میں محدود۔ MCP وضاحت 2025-06-18 کے مطابق، اسٹینڈالون SSE ٹرانسپورٹ کو ڈیپریکیٹ کیا جا چکا ہے اور اس کی جگہ "سٹریم ایبل HTTP" ٹرانسپورٹ نے لے لی ہے۔
• Streamable HTTP: جدید HTTP پر مبنی اسٹریمنگ ٹرانسپورٹ، نوٹیفیکیشنز اور بہتر اسکیل ایبلٹی کو سپورٹ کرتا ہے۔ زیادہ تر پروڈکشن اور کلاؤڈ کے منظرناموں کے لیے تجویز کیا جاتا ہے۔

موازنہ کی میز

نیچے موازنہ کی میز دیکھیں تاکہ ان ٹرانسپورٹ میکانیزمز کے درمیان فرق کو سمجھ سکیں:

ٹرانسپورٹ	حقیقی وقت کی اپڈیٹس	اسٹریمنگ	اسکیل ایبلٹی	استعمال کا معاملہ
stdio	نہیں	نہیں	کم	مقامی CLI آلات
SSE	ہاں	ہاں	درمیانہ	ویب، حقیقی وقت کی اپڈیٹس
Streamable HTTP	ہاں	ہاں	زیادہ	کلاؤڈ، ملٹی کلائنٹ

ٹپ: درست ٹرانسپورٹ کا انتخاب کارکردگی، اسکیل ایبلٹی، اور صارف کے تجربے کو متاثر کرتا ہے۔ Streamable HTTP جدید، قابل توسیع، اور کلاؤڈ کے لیے تیار ایپلیکیشنز کے لیے تجویز کیا جاتا ہے۔

پچھلے ابواب میں آپ کو دکھائے گئے stdio اور SSE ٹرانسپورٹس کو نوٹ کریں اور یہ کہ اس باب میں کس طرح سٹریم ایبل HTTP ٹرانسپورٹ کو شامل کیا گیا ہے۔

اسٹریمنگ: تصورات اور ترغیب

اسٹریمنگ کے بنیادی تصورات اور وجوہات کو سمجھنا مؤثر حقیقی وقت مواصلاتی نظام بنانے کے لیے ضروری ہے۔

اسٹریمنگ نیٹ ورک پروگرامنگ کی ایک تکنیک ہے جو ڈیٹا کو مکمل جوابی جواب کے انتظار کرنے کی بجائے چھوٹے، قابل انتظام حصوں یا ایونٹس کی ترتیب کی صورت میں بھیجنے اور موصول کرنے کی اجازت دیتی ہے۔ یہ خاص طور پر مفید ہے:

• بڑے فائلز یا ڈیٹا سیٹس کے لیے۔
• حقیقی وقت کی اپڈیٹس (مثلاً چیٹ، پروگریس بار) کے لیے۔
• طویل دورانیے کی کمپیوٹیشنز جہاں آپ صارف کو معلومات دینا چاہتے ہیں۔

یہاں اسٹریمنگ کے بارے میں آپ کو جو اعلیٰ سطح پر جاننا ضروری ہے:

• ڈیٹا مرحلہ وار فراہم کیا جاتا ہے، ایک وقت میں سب کچھ نہیں۔
• کلائنٹ ڈیٹا کو پہنچتے ہی پراسیس کر سکتا ہے۔
• محسوس ہونے والی تاخیر کو کم کرتا ہے اور صارف کے تجربے کو بہتر بناتا ہے۔

اسٹریمنگ کیوں استعمال کریں؟

اسٹریمنگ استعمال کرنے کی وجوہات درج ذیل ہیں:

• صارفین کو فوری فیڈبیک ملتا ہے، صرف اختتام پر نہیں
• حقیقی وقت کی ایپلیکیشنز اور جوابی یوزر انٹرفیس کو فعال بناتا ہے
• نیٹ ورک اور کمپیوٹ وسائل کا زیادہ موثر استعمال

سادہ مثال: 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 ایپلیکیشنز کے لیے: MCP کا نوٹیفیکیشن سسٹم طویل مدتی AI کاموں کے لیے خاص طور پر مفید ہے جہاں آپ صارفین کو پیش رفت سے آگاہ رکھنا چاہتے ہیں۔

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 کو message_handler کے ساتھ انیشیلائز کیا گیا ہے تاکہ آنے والی نوٹیفیکیشنز کو ہینڈل کیا جا سکے۔

.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)

سیکیورٹی کے نکات

جب MCP سرورز HTTP پر مبنی ٹرانسپورٹس کے ساتھ نافذ کیے جاتے ہیں، تو سیکیورٹی ایک نہایت اہم مسئلہ بن جاتی ہے جس کے لیے متعدد حملوں کے نقائص اور حفاظتی تدابیر پر غور درکار ہوتا ہے۔

جائزہ

HTTP پر MCP سرورز کو عیاں کرتے وقت سیکیورٹی انتہائی اہم ہے۔ سٹریم ایبل HTTP نئے حملے کے امکانات لے آتا ہے اور محتاط کنفیگریشن کا تقاضا کرتا ہے۔

اہم نکات

• Origin ہیڈر کی تصدیق: DNS ری بائنڈنگ حملوں سے بچاؤ کے لیے ہمیشہ Origin ہیڈر کی تصدیق کریں۔
• لوکل ہوسٹ بندنگ: مقامی ترقی کے لیے سرورز کو 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 پر مبنی ٹرانسپورٹس استعمال کرتے ہوئے، حفاظت اولین ترجیح ہونی چاہیے۔

جب MCP سرورز کو HTTP بیسڈ ٹرانسپورٹس کے ساتھ نافذ کرتے ہیں، تو سیکورٹی ایک اہم تشویش بن جاتی ہے جس میں متعدد حملوں کے زاویے اور حفاظتی میکانزمز پر غور کرنا ضروری ہوتا ہے۔

جائزہ

MCP سرورز کو HTTP پر ظاہر کرتے وقت سیکورٹی بہت اہم ہے۔ Streamable HTTP نئے حملے کے راستے پیش کرتا ہے اور محتاط کنفیگریشن کا تقاضا کرتا ہے۔

یہاں حفاظتی نکات دیے جا رہے ہیں:

• Origin ہیڈر کی تصدیق: DNS ری بائنڈنگ حملوں سے بچنے کے لیے Origin ہیڈر کی ہمیشہ جانچ کریں۔
• لوکل ہوسٹ بائنڈنگ: مقامی ترقی کے لیے سرورز کو localhost پر باندھیں تاکہ انہیں پبلک انٹرنیٹ سے ظاہر نہ کیا جائے۔
• تصدیق (Authentication): پروڈکشن تعیناتیوں کے لیے API کیز یا OAuth جیسی تصدیق نافذ کریں۔
• CORS: کراس اوریجن ریسورس شیئرنگ (CORS) پالیسیاں تشکیل دیں تاکہ رسائی محدود کی جا سکے۔
• HTTPS: ٹریفک کو انکرپٹ کرنے کے لیے پروڈکشن میں HTTPS استعمال کریں۔

بہترین طریقے

یہاں کچھ بہترین طریقے دیے جا رہے ہیں جو MCP اسٹریمنگ سرور میں سیکورٹی نافذ کرتے وقت اپنانے چاہئیں:

• قابل تصدیق کیے بغیر آنے والی درخواستوں پر کبھی بھروسہ نہ کریں۔
• تمام رسائی اور غلطیوں کا لاگ بنائیں اور نگرانی کریں۔
• سیکورٹی کی خامیوں کے پیچز کے لیے باقاعدگی سے انحصارات کو اپ ڈیٹ کریں۔

چیلنجز

MCP اسٹریمنگ سرورز میں سیکورٹی نافذ کرتے ہوئے آپ کو مندرجہ ذیل چیلنجز کا سامنا ہوگا:

• ترقی کی سہولت کے ساتھ حفاظت کا توازن برقرار رکھنا
• مختلف کلائنٹ ماحولیات کے ساتھ مطابقت کو یقینی بنانا

اسائنمنٹ: اپنی اسٹریمنگ MCP ایپ بنائیں

منظرنامہ:
ایک MCP سرور اور کلائنٹ بنائیں جہاں سرور اشیاء کی ایک فہرست (مثلاً فائلیں یا دستاویزات) کو پروسیس کرے اور ہر پروسیس شدہ آئٹم کے لیے نوٹیفکیشن بھیجے۔ کلائنٹ کو چاہیے کہ وہ ہر نوٹیفکیشن کو جوں ہی آئے دکھائے۔

مراحل:

1. ایک ایسا سرور ٹول نافذ کریں جو فہرست کو پروسیس کرے اور ہر آئٹم کے لیے نوٹیفکیشن بھیجے۔
2. ایک کلائنٹ نافذ کریں جس میں میسج ہینڈلر ہو جو نوٹیفکیشن کو حقیقی وقت میں ظاہر کرتا ہو۔
3. اپنے نفاذ کا ٹیسٹ کریں، سرور اور کلائنٹ دونوں چلائیں، اور نوٹیفکیشنز کا مشاہدہ کریں۔

حل

مزید مطالعہ اور آگے کیا؟

اپنے MCP اسٹریمنگ کے سفر کو جاری رکھنے اور اپنے علم کو بڑھانے کے لیے، یہ سیکشن اضافی وسائل اور مزید ترقی یافتہ ایپلیکیشنز بنانے کے اگلے اقدامات فراہم کرتا ہے۔

مزید مطالعہ

• Microsoft: HTTP اسٹریمنگ کا تعارف
• Microsoft: سرور سینٹ ایونٹس (SSE)
• Microsoft: ASP.NET Core میں CORS
• Python requests: اسٹریمنگ ریکویسٹس

آگے کیا؟

• حقیقی وقت کی اینالٹکس، چیٹ، یا مشترکہ تدوین کے لیے اسٹریمنگ استعمال کرنے والے مزید ترقی یافتہ MCP ٹولز بنانے کی کوشش کریں۔
• فرنٹ اینڈ فریم ورکس (React, Vue، وغیرہ) کے ساتھ MCP اسٹریمنگ کو مربوط کرنے کی تحقیق کریں تاکہ لائیو UI اپڈیٹس ہوں۔
• اگلا: VSCode کے لیے AI Toolkit کا استعمال

---

ڈس کلیمر: یہ دستاویز AI ترجمہ سروس Co-op Translator کے ذریعے ترجمہ کی گئی ہے۔ جبکہ ہم درستگی کے لیے کوشاں ہیں، براہ کرم اس بات سے آگاہ رہیں کہ خودکار ترجمے میں غلطیاں یا عدم درستیاں ہو سکتی ہیں۔ اصل دستاویز اپنے مادری زبان میں مستند ماخذ سمجھی جائے گی۔ حساس معلومات کے لیے پیشہ ور انسانی ترجمہ کی سفارش کی جاتی ہے۔ اس ترجمے کے استعمال سے پیدا ہونے والی کسی بھی غلط فہمی یا غلط تشریح کی ذمہ داری ہم قبول نہیں کرتے۔