Files

T

wehub-resource-sync c275ba2868 chore: import upstream snapshot with attribution

2026-07-13 13:31:35 +08:00

52 KiB

Raw Permalink Blame History

HTTPS ಸಂಸ್ಕರಣಾ ಪ್ರೋಟೋಕಾಲ್ (MCP) ಮೂಲಕ ಸ್ಟ್ರೀಮಿಂಗ್

ಈ ಅಧ್ಯಾಯವು HTTPS ಬಳಸಿ ಮೋಡೆಲ್ ಕಾನ್‌ಟೆಕ್ಸ್ಟ್ ಪ್ರೋಟೋಕಾಲ್ (MCP) ಜೊತೆಗೆ ಭದ್ರ, ತಲುಪಬಹುದಾದ ಮತ್ತು ರಿಯಲ್-ಟೈಮ್ ಸ್ಟ್ರೀಮಿಂಗ್ ಅನುಷ್ಠಾನಗೊಳಿಸುವ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದರೊಳಗೆ ಸ್ಟ್ರೀಮಿಂಗ್‌ನ ಪ್ರೇರಣೆ, ಲಭ್ಯವಿರುವ ಸಾರಿಗೆ ಮೆಕಾನಿಸಮ್‌ಗಳು, 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 ಸಾರಿಗೆ ಹೇಗಿದೆ ಎಂಬುದನ್ನೂ ಗಮನಿಸಿ.

ಸ್ಟ್ರೀಮಿಂಗ್: ಆಧಾರಭೂತ ತತ್ವಗಳು ಮತ್ತು ಪ್ರೇರಣೆ

ಸ್ಟ್ರೀಮಿಂಗ್‌ನ ಮೂಲ ಸಂಜ್ಞಾನ ಮತ್ತು ಪ್ರೇರಣೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಪರಿಣಾಮಕಾರಿ ರಿಯಲ್-ಟೈಂ ಸಂವಹನ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಅತ್ಯವಶ್ಯಕ.

ಸ್ಟ್ರೀಮಿಂಗ್ ಎಂಬುದು ನೆಟ್‌ವರ್ಕ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ದತ್ತಾಂಶವನ್ನು ಸಂಪೂರ್ಣ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಕಾಯದೆ ಸಣ್ಣ, ನಿರ್ವಹಣೆಯಾದ ತುಂಡುಗಳಾಗಿ ಅಥವಾ ಘಟನೆಗಳ ಸರಣಿ ರೂಪದಲ್ಲಿ ಕಳಿಸಲು ಮತ್ತು ಸ್ವೀಕರಿಸಲು ಅನುಮತಿಸುವ ತಂತ್ರ. ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗುತ್ತದೆ:

ದೊಡ್ಡ ಫೈಲ್‌ಗಳು ಅಥವಾ ಡೇಟಾಸೆಟ್‌ಗಳು.
ರಿಯಲ್-ಟೈಮ್ ನವೀಕರಣಗಳು (ಉದಾ: ಚಾಟ್, ಪ್ರಗತಿ ಬಾರ್‌ಗಳು).
ಹಗಲು-ರಾತ್ರಿಯಾದ ಗಣನೆಗಳು, ಬಳಕೆದಾರರಿಗೆ ಪ್ರಗತಿಯ ಕುರಿತು ತಿಳಿಸಲು.

ಹೆಚ್ಚಿನ ಮಟ್ಟದಲ್ಲಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದವು:

ದತ್ತಾಂಶ ಕ್ರಮವಾಗಿ ನೀಡಲಾಗುತ್ತದೆ, ಎಲ್ಲವನ್ನೂ ಒಮ್ಮೆಗೂ ನೀಡುವುದಿಲ್ಲ.
ಗ್ರಾಹಕರು ದತ್ತಾಂಶವನ್ನು ಬರುವಂತೆ ಪ್ರಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬಳಸಬಹುದು.
ಅಂದಾಜು ಪ್ರತಿ ಕಡಿಮೆ ಆಗುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರ ಅನುಭವ ಸುಧಾರಿಸುತ್ತದೆ.

ಸ್ಟ್ರೀಮಿಂಗ್ ಯಾಕೆ ಬಳಸಬೇಕು?

ಸ್ಟ್ರೀಮಿಂಗ್ ಬಳಸಬೇಕಾದ ಪ್ರಮುಖ ಕಾರಣಗಳು:

ಬಳಕೆದಾರರು ತಕ್ಷಣ ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆಯುತ್ತಾರೆ, ಕೇವಲ ಕೊನೆಯಲ್ಲಿ ಅಲ್ಲ.
ರಿಯಲ್-ಟೈಮ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾಶೀಲ UI ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ನೆಟ್‌ವರ್ಕ್ ಮತ್ತು ಗಣನೆ ಸಂಪನ್ಮೂಲಗಳ ಪರಿಣಾಮಕಾರಿ ಬಳಕೆ.

ಸರಳ ಉದಾಹರಣೆ: HTTP ಸ್ಟ್ರೀಮಿಂಗ್ ಸರ್ವರ್ ಮತ್ತು ಗ್ರಾಹಕ

ಸ್ಟ್ರೀಮಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಅನುಷ್ಠಾನಗೊಳಿಸಬಹುದು ಎಂಬ ಸರಳ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ಪೈಥಾನ್

ಸರ್ವರ್ (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 ನಲ್ಲಿ).
ಕಾಂಟೆಂಟ್-ಟೈಪ್ ಸಾಮಾನ್ಯವಾಗಿ text/event-stream ಅಥವಾ application/octet-stream.

ಜಾವಾ

ಸರ್ವರ್ (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();
    }
}

ಜಾವಾ ಅನುಷ್ಠಾನ ಟಿಪ್ಸ್:

ಸ್ಟ್ರೀಮಿಂಗ್‌ಗಾಗಿ 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 ಸನ್ನಿವೇಶದಲ್ಲಿ ಅದಕ್ಕೆ ಅರ್ಥವೇನೆಂದು ನೋಡೋಣ.

ಅಧಿಸೂಚನೆ ಎಂದರೆ ಸರ್ವರ್‌ನಿಂದ ಗ್ರಾಹಕಕ್ಕೆ ಕಳುಹಿಸಲಾಗುವ ಸಂದೇಶ, ಅದು ದೀರ್ಘಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆ ವೇಳೆ ಪ್ರಗತಿ, ಸ್ಥಿತಿ ಅಥವಾ ಇತರೆ ಘಟನೆಗಳನ್ನು ತಿಳಿಸುತ್ತದೆ. ಅಧಿಸೂಚನೆಗಳು ಪಾರದರ್ಶಕತೆ ಮತ್ತು ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತವೆ.

ಉದಾಹರಣೆಗೆ, ಪ್ರಾಥಮಿಕ ಸಹಿ ವಿನಿಮಯ (initial handshake) ಸರ್ವರ್ ಜೊತೆ ಮಾಡಿದ ನಂತರ ಗ್ರಾಹಕ ಒಂದು ಅಧಿಸೂಚನೆಯನ್ನು ಕಳುಹಿಸಬೇಕು.

ಅಧಿಸೂಚನೆ JSON ಸಂದೇಶ ಚಿತ್ರದಂತೆ ಕಾಣುತ್ತದೆ:

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

ಅಧಿಸೂಚನೆಗಳು MCP ನಲ್ಲಿ "ಲಾಗಿಂಗ" ಎಂಬ ವಿಷಯಕ್ಕೆ ಸೇರಿವೆ.

ಲಾಗಿಂಗ್ ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ಸರ್ವರ್ ಇದು ಒಂದು ವೈಶಿಷ್ಟ್ಯ / ಸಾಮರ್ಥ್ಯವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು:

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

Note

ಬಳಸುತ್ತಿರುವ SDK ಕುರಿತಂತೆ, ಲಾಗಿಂಗ್ ಡೀಫಾಲ್ಟ್ ಆಗಿ ಸಕ್ರಿಯವಾಗಿರಬಹುದು ಅಥವಾ ನೀವು ಸರ್ವರ್ ಸಂರಚನೆಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಬೇಕಾಗಬಹುದು.

ಬೇರೆ ವಿಧದ ಅಧಿಸೂಚನೆಗಳು ಇದ್ದವೆ:

ಮಟ್ಟ	ವಿವರಣೆ	ಉದಾಹರಣೆ ಬಳಕೆ
debug	ವಿವರವಾದ ಡಿಬಗ್ಗಿಂಗ್ ಮಾಹಿತಿ	ಕಾರ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸುವ/ಮೂಡಿಕೊಳ್ಳುವ ಸ್ಥಳಗಳು
info	ಸಾಮಾನ್ಯ ಮಾಹಿತಿ ಸಂದೇಶಗಳು	ಕಾರ್ಯ ಪ್ರಗತಿ ನವೀಕರಣಗಳು
notice	ಸಾಮಾನ್ಯ ಆದರೆ ಪ್ರಮುಖ ಘಟನೆಗಳು	ಸಂರಚನಾ ಬದಲಾವಣೆಗಳು
warning	ಎಚ್ಚರಿಕೆ ಸ್ಥಿತಿಗಳು	ಹಳೆಯದಾಗಿ ಪರಿಗಣಿಸಲಾದ ವೈಶಿಷ್ಟ್ಯ ಬಳಕೆ
error	ದೋಷಗಳ ಸ್ಥಿತಿಗಳು	ಕಾರ್ಯ ವೈಫಲ್ಯಗಳು
critical	ಗಂಭೀರ ಸ್ಥಿತಿಗಳು	ವ್ಯವಸ್ಥೆಯ ಘಟಕ ವೈಫಲ್ಯಗಳು
alert	ತಕ್ಷಣ ಕ್ರಮ ಕೈಗೊಳ್ಳುವುದು ಅಗತ್ಯ	ದತ್ತಾಂಶ ನಾಶವಾಗಿರುವುದು ಪತ್ತೆಯಾದುದು
emergency	ವ್ಯವಸ್ಥೆ ನಿರ್ಬಂಧಿತವಾಗಿದೆ	ಸಂಪೂರ್ಣ ವ್ಯವಸ್ಥೆ ವೈಫಲ್ಯ

MCP ನಲ್ಲಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

MCP ನಲ್ಲಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು, ನೀವು ಸರ್ವರ್ ಮತ್ತು ಗ್ರಾಹಕ ಎರಡರನ್ನೂ ರಿಯಲ್-ಟೈಮ್ ನವೀಕರಣಗಳನ್ನು ಹ್ಯಾಂಡಲ್ ಮಾಡಲು ಸಿದ್ಧಪಡಿಸಬೇಕು. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ದೀರ್ಘಕಾಲದ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ ತಕ್ಷಣ ಪ್ರತಿಕ್ರಿಯೆ ನೀಡುವುದಕ್ಕೆ ಅನುಮತಿಸುತ್ತದೆ.

ಸರ್ವರ್-ಪಕ್ಷ: ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವುದು

ಸರ್ವರ್‌ಮೇಲೆ ಪ್ರಾರಂಭಿಸೋಣ. MCP ನಲ್ಲಿ ನೀವು ಒಂದು ಉಪಕರಣವನ್ನು (tool) ಸಂಯೋಜಿಸುತ್ತೀರಿ ಅದು ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡುತ್ತಿರುವಾಗ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸಬಹುದು. ಸರ್ವರ್ ಥಾರೆಯ ಆದರ್ಶ ವಸ್ತುವಿನು (ಸಾಮಾನ್ಯವಾಗಿ ctx) ಗ್ರಾಹಕನಿಗೆ ಸಂದೇಶ ಕಳುಹಿಸಲು ಬಳಸುತ್ತದೆ.

ಪೈಥಾನ್

@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 ಉಪಕರಣವು ಪ್ರತಿ ಫೈಲ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಮೂರು ಅಧಿಸೂಚನೆಗಳನ್ನು ಗ್ರಾಹಕ್ನಿಗೆ ಕಳುಹಿಸುತ್ತದೆ. ctx.Info() ವಿಧಾನವು ಮಾಹಿತಿ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಬಳಸಲಾಗಿದೆ.

ನಿಮ್ಮ .NET MCP ಸರ್ವರ್‌ನಲ್ಲಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ಸ್ಟ್ರೀಮಿಂಗ್ ಸಾರಿಗೆಯನ್ನು ಉಪಯೋಗಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

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

ಗ್ರಾಹಕ-ಪಕ್ಷ: ಅಧಿಸೂಚನೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು

ಗ್ರಾಹಕವು ಬರುತ್ತಿರುವ ಅಧಿಸೂಚನೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ ಪ್ರದರ್ಶಿಸಲು ಸಂದೇಶ ನಿರ್ವಾಹಕವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಬೇಕು.

ಪೈಥಾನ್

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() ಮೂಲಕ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸಿ. ಇದು ಮುಖ್ಯ ಫಲಿತಾಂಶ ಸಿದ್ಧವಾಗುವ ಮೊದಲು ಗ್ರಾಹಕಕ್ಕೆ ಸಂದೇಶ ಕಳುಹಿಸುತ್ತದೆ.
ಗ್ರಾಹಕ‌ನಲ್ಲಿ: ಅಧಿಸೂಚನೆಗಳನ್ನು ಬರುವಂತೆ ಎರಕವಾಗಿ ಗುರುತಿಸಿ ಪ್ರದರ್ಶಿಸುವ ಸಂದೇಶ ನಿರ್ವಾಹಕವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ. ಈ ನಿರ್ವಾಹಕ ಅಧಿಸೂಚನೆಗಳು ಮತ್ತು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ವಿಭಿನ್ನವಾಗಿ ಪರಿಚಯಿಸಬೇಕು.

ಸರ್ವರ್ ಉದಾಹರಣೆ:

ಪೈಥಾನ್

@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}")

ಗ್ರಾಹಕ ಉದಾಹರಣೆ:

ಪೈಥಾನ್

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

ಭದ್ರತಾ ಪರಿಗಣನೆಗಳು

HTTP ಆಧಾರಿತ ಸಾರಿಗೆಯೊಂದಿಗೆ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವಾಗ, ಭದ್ರತೆ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದ್ದು, ಹಲವು ದಾಳಿಸ್ಥಾನಗಳು ಮತ್ತು ರಕ್ಷಣಾ ಯಂತ್ರాంగಗಳನ್ನು ಸಂಯಮದಿಂದ ಗಮನಿಸುವ ಅಗತ್ಯವಿದೆ.

ಅವಲೋಕನ

HTTP ಮೂಲಕ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುವಾಗ ಭದ್ರತೆ ನಿಶ್ಚಿತವಾಗಿದೆ. Streamable HTTP ಹೊಸ ದಾಳಿ ಸಾಧ್ಯತೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ ಮತ್ತು ಸಂಯಮಿತ ಸಂರಚನೆಯನ್ನು ಅಗತ್ಯವಾಗಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಅಂಶಗಳು

Origin ಹೆಡರ್ ಪರಿಶೀಲನೆ: DNS ರಿಬಾಂಡಿಂಗ್ ದಾಳಿಗಳನ್ನು ತಡೆಗಟ್ಟಲು Origin ಹೆಡರ್ ಎల్లತ್ತಿ ಪರಿಶೀಲಿಸಿ.
ಸ್ಥಳೀಯ ಹೋಸ್ಟ್ ಬಾಂಧವ್ಯ: ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗಾಗಿ, ಸರ್ವರ್‌ಗಳನ್ನು localhost ಗೆ ಬಾಂಧಿಸಿ ಜನ ಸಾಮಾನ್ಯ ಅಂತರ್ಜಾಲಕ್ಕೆ ಬಹಿರಂಗ ಮಾಡಬೇಡಿ.
ಪ್ರಮಾಣೀಕರಣ: ಉತ್ಪಾದನಾ ನಿಯೋಜನೆಗಳಿಗಾಗಿ ಪ್ರಮಾಣೀಕರಣ (ಉದಾ: API ಕೀಗಳು, OAuth) ಅನುಷ್ಠಾನಗೊಳಿಸಿ.
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 ಎರಡನ್ನೂ ವಿಭಿನ್ನ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ಬೆಂಬಲಿಸಬಹುದು.
ಗ್ರಾಹಕರನ್ನು ಹಂತ ಹಂತವಾಗಿ ಹೊಸ ಸಾರಿಗೆಗೆ ಸ್ಥಳಾಂತರಿಸಬಹುದು.

ಸವಾಲುಗಳು

ಸ್ಥಾನಾಂತರದ ಸಮಯದಲ್ಲಿ ಈ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುವುದು ಜರು.

ಎಲ್ಲಾ ಗ್ರಾಹಕರು ನವೀಕರಿಸಲ್ಪಡುವುದನ್ನು ಖಚಿತಪಡಿಸುವುದು
ಅಧಿಸೂಚನೆಯ ವಿತರಣೆಯಲ್ಲಿನ ವಿಭಿನ್ನತೆಯನ್ನು ಸಂಭಾಳಿಸುವುದು

ಭದ್ರತೆ ಪರಿಗಣನೆಗಳು

ಹೆಚ್ಚು ಭದ್ರತೆಯ ಅಗತ್ಯ ಇದ್ದಾಗ ಯಾವತ್ತೂ HTTP ಆಧಾರಿತ ಸಾರಿಗೆಗಳ ಜೊತೆಗೆ MCP ಸರ್ವರ್ ನಿರ್ಮಿಸುವಾಗ ಭದ್ರತೆ ಮುಖ್ಯ ಆದ್ಯತೆಯಾಗಿರುತ್ತದೆ.

MCP ಸರ್ವರ್‌ಗಳನ್ನು HTTP ಆಧಾರಿತ ಸಾರಿಗೆಯೊಂದಿಗೆ ಪರಿಚಯಿಸುವಾಗ ಭದ್ರತೆ ಒಂದು ಪ್ರಮುಖ ಸಮಸ್ಯೆಯಾಗಿ ಆಗಿದ್ದು, ಇದಕ್ಕೆ ಅನೇಕ ದಾಳಿಗಳ ಮತ್ತು ರಕ್ಷಣೆ ವಿಧಾನಗಳ ಮೇಲೆ ಕಾಳಜಿ ವಹಿಸುವ ಅಗತ್ಯವಿದೆ.

ಅವಲೋಕನ

MCP ಸರ್ವರ್‌ಗಳನ್ನು HTTP ಮೂಲಕ ಪ್ರಕಟಿಸುವಾಗ ಭದ್ರತೆ ಅತ್ಯಂತ ಮುಖ್ಯ. Streamable HTTP ಹೊಸ ದಾಳಿ ಮೇಲ್ಮೈಗಳನ್ನು ಪರಿಚಯಿಸಿ, ನಿಖರವಾಗಿ ಸಂರಚನೆ ಅಗತ್ಯಗೊಳಿಸುತ್ತದೆ.

ಮುಖ್ಯ ಭದ್ರತೆ ಪರಿಗಣನೆಗಳು:

Origin Header ಪರಿಶೀಲನೆ: DNS ಮರುಬಂಧನ ದಾಳಿಗಳನ್ನು ತಪ್ಪಿಸಲು Origin ಹೆಡರ್‌ನ್ನು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಿ.
ಲೋಕಲ್‌ಹೋಸ್ಟ್ ಬಾಂಧವ್ಯ: ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸರ್ವರ್ ಅನ್ನು localhostಗೆ ಬાંધી, ಸಾರ್ವಜನಿಕ ಇಂಟರ್ನೆಟ್‌ಗೆ ಪ್ರಕಟಿಸಬೇಡಿ.
ಪ್ರಮಾಣೀಕರಣ: ಉತ્પાદನಾ ನಿಯೋಜನೆಗಳಿಗಾಗಿ ಪ್ರಮಾಣೀಕರಣ (ಉದಾಹರಣೆಗೆ, API ಕೀಗಳು, OAuth) ಜಾರಿಗೊಳಿಸಿ.
CORS: ಕೌಟುಂಬಿಕ ಮೂಲ ಹಂಚಿಕೆ ನೀತಿಗಳನ್ನು ಗಡಿ ಮಾರು.
HTTPS: ಉತ્પાદನದಲ್ಲಿ ಸಂಚಾರವನ್ನು ಸಂಕೇತಗೊಳಿಸಲು HTTPS ಬಳಿಯಿರಿ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನಿಮ್ಮ MCP ಸ್ಟ್ರೀಮಿಂಗ್ ಸರ್ವರ್‌ನಲ್ಲಿ ಭದ್ರತೆ ಅನುಷ್ಠಾನ ಮಾಡುವಾಗ ಅನುಸರಿಸಲು ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು:

ಪರಿಶೀಲನೆ ಇಲ್ಲದೆ ಬಂದಿರುವ ವಿನಂತಿಗಳನ್ನು ಎಂದಿಗೂ ನಂಬಬೇಡಿ.
ಎಲ್ಲಾ ಪ್ರವೇಶ ಮತ್ತು ದೋಷಗಳನ್ನು ಲಾಗ್ ಮಾಡಿ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ.
ಭದ್ರತೆ ದುರ್ಬಲತೆಗಳನ್ನು ತಡೆಗಟ್ಟಲು ನಿಯಮಿತವಾಗಿ ಅವಲಂಬನೆಗಳನ್ನು ನವೀಕರಿಸಿ.

ಸವಾಲುಗಳು

MCP ಸ್ಟ್ರೀಮಿಂಗ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಭದ್ರತೆ ಅನುಷ್ಠಾನಗೊಳಿಸುವಾಗ ನೀವು ಎದುರಿಸುವ ಕೆಲವು ಸವಾಲುಗಳು:

ಅಭಿವೃದ್ಧಿಗೆ ಸುಲಭತೆ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಸಮತೋಲನ ಸಾಧಿಸುವುದು
ವಿವಿಧ ಗ್ರಾಹಕ ಪರಿಸರಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆ ಖಚಿತಪಡಿಸುವುದು

ಕಾರ್ಯ: ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಟ್ರೀಮಿಂಗ್ MCP ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ

ಘಟನೆ: ಒಂದು MCP ಸರ್ವರ್ ಮತ್ತು ಗ್ರಾಹಕವನ್ನು ನಿರ್ಮಿಸಿ, ಅಲ್ಲಿ ಸರ್ವರ್ ಐಟಂಗಳ ಪಟ್ಟಿಯನ್ನು (ಉದಾ: ಕಡತಗಳು ಅಥವಾ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳು) ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಗೆ ಒಂದು ಅಧಿಸೂಚನೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಗ್ರಾಹಕ ಪ್ರತಿ ಅಧಿಸೂಚನೆಯನ್ನು ಬಂದಂತೆ ತೋರಿಸಬೇಕು.

ಹಂತಗಳು:

ಪ್ರತಿ ಐಟಂಗೆ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವಂತೆ ಪಟ್ಟಿಯನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡBarrು ಸರ್ವರ್ ಉಪಕರಣವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ.
ವಾಸ್ತವಿಕ ಸಮಯದಲ್ಲಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಸಂದೇಶ ನಿರ್ವಹಣಾ ಕಾರ್ಯ ಹೊಂದಿರುವ ಗ್ರಾಹಕವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಿ.
ನಿಮ್ಮ ಅನುಷ್ಠಾನವನ್ನು ಸರ್ವರ್ ಮತ್ತು ಗ್ರಾಹಕ ಎರಡನ್ನೂ ರನ್ ಮಾಡಿ ಪರೀಕ್ಷಿಸಿ ಮತ್ತು ಅಧಿಸೂಚನೆಗಳನ್ನು ಗಮನಿಸು.

Solution

ಹೆಚ್ಚಿನ ಓದು ಮತ್ತು ಮುಂದಿನ ಹಂತ

MCP ಸ್ಟ್ರೀಮಿಂಗ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಪ್ರಯಾಣ ಮುಂದುವರಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಜ್ಞಾನವನ್ನು ವಿಸ್ತರಿಸಲು, ಈ ವಿಭಾಗವು ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಹೆಚ್ಚಿನ ಅದ್ಯತಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಶಿಫಾರಸು ಮಾಡಿದ ಮುಂದಿನ ಹಂತಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಹೆಚ್ಚುವರಿ ಓದು

ಮುಂದಿನ ಹಂತ?

ರಿಯಲ್-ಟೈಮ್ ವಿಶ್ಲೇಷಣೆ, ಚಾಟ್ ಅಥವಾ ಸಹಗಾಮಿ ಸಂಪಾದನೆಗಾಗಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಬಳಸಿ ಹೆಚ್ಚು ಉನ್ನತ MCP ಸಾಧನಗಳನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಯತ್ನ ಮಾಡಿ.
MCP ಸ್ಟ್ರೀಮಿಂಗ್‌ನ್ನು ಫ್ರಂಟೆಂಡ್ ಫ್ರೇಮ್ವರ್ಕ್‌ಗಳೊಂದಿಗೆ (React, Vue, ಇತ್ಯಾದಿ) ಜೋಡಿಸಿ ಜೀವಂತ UI ನವೀಕರಣಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.
ಮುಂದಿನದು: VSCode ಗೆ AI ಕಾರ್ಯಸರಣಿ ಉಪಕರಣ ಉಪಯೋಗಿಸುವುದು

ಅಸ್ವೀಕಾರ: ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸಡ್ಡೆಗಳು ಇರಬಹುದು. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜು ಪ್ರಾಮಾಣಿಕ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಮೂಲಕ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಗಳ ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.

52 KiB Raw Permalink Blame History

HTTPS ಸಂಸ್ಕರಣಾ ಪ್ರೋಟೋಕಾಲ್ (MCP) ಮೂಲಕ ಸ್ಟ್ರೀಮಿಂಗ್

MCP ನಲ್ಲಿ ಸಾರಿಗೆ ಮೆಕಾನಿಸಮ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರೀಮಿಂಗ್

ಸಾರಿಗೆ ಮೆಕಾನಿಸಮ್ ಎಂದರೇನು?

ಹೋಲಿಕೆ ಟೇಬಲ್

ಸ್ಟ್ರೀಮಿಂಗ್: ಆಧಾರಭೂತ ತತ್ವಗಳು ಮತ್ತು ಪ್ರೇರಣೆ

ಸ್ಟ್ರೀಮಿಂಗ್ ಯಾಕೆ ಬಳಸಬೇಕು?

ಸರಳ ಉದಾಹರಣೆ: HTTP ಸ್ಟ್ರೀಮಿಂಗ್ ಸರ್ವರ್ ಮತ್ತು ಗ್ರಾಹಕ

ಪೈಥಾನ್

ಜಾವಾ

ಹೋಲಿಕೆ: ಕ್ಲಾಸಿಕ್ ಸ್ಟ್ರೀಮಿಂಗ್ ಮತ್ತು MCP ಸ್ಟ್ರೀಮಿಂಗ್

ಗಮನಿಸುವ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳು

ಶಿಫಾರಸುಗಳು

MCP ನಲ್ಲಿ ಸ್ಟ್ರೀಮಿಂಗ್

ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಅಧಿಸೂಚನೆ ಎಂದರೇನು?

MCP ನಲ್ಲಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

ಸರ್ವರ್-ಪಕ್ಷ: ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವುದು

ಪೈಥಾನ್

.NET

ಗ್ರಾಹಕ-ಪಕ್ಷ: ಅಧಿಸೂಚನೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು

ಪೈಥಾನ್

.NET

ಪ್ರಗತಿ ಅಧಿಸೂಚನೆಗಳು ಮತ್ತು ಸನ್ನಿವೇಶಗಳು

ಪ್ರಗತಿ ಅಧಿಸೂಚನೆಗಳನ್ನು ಯಾಕೆ ಬಳಸಬೇಕು?

ಪ್ರಗತಿ ಅಧಿಸೂಚನೆಗಳ ಅನುಷ್ಠಾನ ಹೇಗೆ?

ಪೈಥಾನ್

ಪೈಥಾನ್

ಭದ್ರತಾ ಪರಿಗಣನೆಗಳು

ಅವಲೋಕನ

ಪ್ರಮುಖ ಅಂಶಗಳು

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸವಾಲುಗಳು

SSEನಿಂದ Streamable HTTPಗೆ ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡುವುದು

ಏಕೆ ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡಬೇಕು?

ಸ್ಥಳಾಂತರ ಹಂತಗಳು

ಹೊಂದಾಣಿಕೆಯನ್ನು ಪಾಳು-ತಾಳುವುದು

ಸವಾಲುಗಳು

ಭದ್ರತೆ ಪರಿಗಣನೆಗಳು

ಅವಲೋಕನ

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸವಾಲುಗಳು

ಕಾರ್ಯ: ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಟ್ರೀಮಿಂಗ್ MCP ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ

ಹೆಚ್ಚಿನ ಓದು ಮತ್ತು ಮುಂದಿನ ಹಂತ

ಹೆಚ್ಚುವರಿ ಓದು

ಮುಂದಿನ ಹಂತ?

52 KiB

Raw Permalink Blame History