मॉडल संदर्भ प्रोटोकॉल (MCP)

दस्तावेज़ मानचित्र: अवलोकन और वास्तुकला · क्लाइंट · डायनामिक मैनेजर · सर्वर ऑथरिंग · सुरक्षा · परीक्षण

MCP एक AI एप्लिकेशन को किसी अन्य प्रक्रिया या सेवा के स्वामित्व वाली क्षमताओं को खोजने और उपयोग करने का एक मानक तरीका देता है। एक सर्वर प्रकाशित कर सकता है:

• tools जो क्रियाएं करते हैं;
• resources जो पठनीय संदर्भ लौटाते हैं;
• prompts जो पुन: प्रयोज्य संदेश टेम्पलेट प्रदान करते हैं; और
• completion सुझाव जो क्लाइंट को prompt या resource आर्ग्यूमेंट्स भरने में मदद करते हैं।

ADK-Rust आमतौर पर MCP client होता है। McpToolset खोजे गए MCP tools को सामान्य ADK-Rust Tool मानों में बदल देता है, ताकि एक LlmAgent उन्हें चुन और कॉल कर सके। फ्रेमवर्क resources, prompts, completion, subscriptions, elicitation और नेगोशिएटेड टास्क लाइफसाइकिल को भी उजागर करता है। MCP server authoring और उन्नत प्रोटोकॉल कार्य के लिए, ADK-Rust उस सटीक rmcp SDK संस्करण को फिर से निर्यात करता है जिसका वह उपयोग करता है।

ADK-Rust 2 वर्तमान में rmcp 2.2 का उपयोग करता है, जो MCP 2025-11-25 स्पेसिफिकेशन के साथ संरेखित आधिकारिक Rust SDK है।

वास्तुकला

Rendering architecture…

दो अलग-अलग परतें हैं:

1. McpToolset एक आरंभिक MCP client कनेक्शन का मालिक है। यह सर्वर की क्षमताओं को खोजता है और उन्हें ADK-Rust के अनुकूल बनाता है।
2. McpServerManager स्थानीय stdio सर्वर के बदलते रजिस्ट्री का मालिक है। यह उन कनेक्शनों को शुरू करता है, मॉनिटर करता है, पुनरारंभ करता है, अपडेट करता है, सक्षम करता है, अक्षम करता है, बनाए रखता है और एकत्रित करता है।

मैनेजर tool अनुमोदन प्रदान नहीं करता है। यह संगत कॉन्फ़िगरेशन पढ़ते समय autoApprove को संरक्षित करता है, लेकिन एप्लिकेशन को अपनी सामान्य ADK-Rust प्राधिकरण और अनुमोदन नीति लागू करनी चाहिए।

स्थापित करें

स्थानीय stdio MCP समर्थन ऑप्ट-इन है:

[dependencies]
adk-tool = { version = "2.0.0", features = ["mcp"] }

रिमोट सेवाओं से कनेक्ट करते समय Streamable HTTP जोड़ें:

adk-tool = { version = "2.0.0", features = ["mcp", "http-transport"] }

लेगेसी सैंपलिंग कॉलबैक के लिए अलग mcp-sampling सुविधा की आवश्यकता होती है। MCP प्रोजेक्ट ने SEP-2577 के माध्यम से सैंपलिंग, रूट्स और लॉगिंग को हटा दिया है; उन APIs का उपयोग केवल तभी करें जब आप एक संगत डिप्लॉयमेंट बनाए रख रहे हों।

एक स्थानीय सर्वर कनेक्ट करें

use adk_tool::{
    McpToolset,
    mcp::rmcp::{ServiceExt, transport::TokioChildProcess},
};
use std::sync::Arc;
use tokio::process::Command;

let command = Command::new("./target/release/company-mcp");
let client = ().serve(TokioChildProcess::new(command)?).await?;

let toolset = McpToolset::new(client)
    .with_name("company_tools")
    .with_tools(&["find_customer", "read_order", "request_refund"]);

let agent = LlmAgentBuilder::new("support")
    .model(model)
    .toolset(Arc::new(toolset.clone()))
    .build()?;

// Keep the token when the application owns the process lifecycle.
let shutdown = toolset.cancellation_token().await;
// ... run the agent ...
shutdown.cancel();

McpToolset सर्वर के इनपुट और आउटपुट स्कीमा को बरकरार रखता है। प्रत्येक मॉडल एडाप्टर मॉडल अनुरोध बनाते समय अपने प्रदाता के लिए एक प्रति को सामान्य करता है। यह उसी MCP सर्वर को Gemini, OpenAI, Anthropic और अन्य प्रदाताओं के साथ स्रोत स्कीमा को नुकसान पहुंचाए बिना काम करने देता है।

tools से परे प्रोटोकॉल का उपयोग करें

use serde_json::json;

let resources = toolset.list_resources().await?;
let templates = toolset.list_resource_templates().await?;
let contents = toolset.read_resource("company://policy/refunds").await?;

let prompts = toolset.list_prompts().await?;
let prompt = toolset
    .get_prompt(
        "investigate_order",
        Some(serde_json::Map::from_iter([
            ("order_id".to_string(), json!("ORD-1042")),
        ])),
    )
    .await?;

let suggestions = toolset
    .complete_prompt_argument("investigate_order", "order_id", "ORD-", None)
    .await?;

toolset.subscribe_resource("company://inventory/sku-42").await?;
// ... receive notifications in a custom ClientHandler ...
toolset.unsubscribe_resource("company://inventory/sku-42").await?;

सुविधा विधियाँ एक खाली सूची लौटाती हैं जब कोई पुराना सर्वर resource या prompt लिस्टिंग को लागू नहीं करता है। घोषित resource या prompt के विरुद्ध संचालन एक त्रुटि लौटाता है जब रिमोट कॉल विफल हो जाता है।

डायनामिक सर्वर प्रबंधन

McpServerManager का उपयोग करें जब एप्लिकेशन को एक स्थिर कनेक्शन के बजाय स्थानीय MCP चाइल्ड प्रक्रियाओं के बेड़े की आवश्यकता हो।

use adk_tool::mcp::manager::{McpServerConfig, McpServerManager};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;

let manager = Arc::new(McpServerManager::from_json_file("mcp.json")?
    .with_name("product_mcp_servers")
    .with_health_check_interval(Duration::from_secs(15))
    .with_grace_period(Duration::from_secs(2)));

let outcomes = manager.start_all().await;
for (server_id, outcome) in outcomes {
    if let Err(error) = outcome {
        eprintln!("{server_id} did not start: {error}");
    }
}
manager.start_monitoring();

let agent = LlmAgentBuilder::new("operator")
    .model(model)
    .toolset(manager.clone())
    .build()?;

रनटाइम रजिस्ट्री समर्थन करती है:

manager.add_server("billing".into(), billing_config).await?;
manager.start_server("billing").await?;

manager.update_server("billing", replacement_config).await?;
manager.disable_server("billing").await?;
manager.enable_server("billing").await?;

manager.save_json_file("mcp.json").await?;
manager.remove_server("billing").await?;
manager.shutdown().await?;

जब दो सर्वर एक ही tool नाम प्रकाशित करते हैं, तो एकत्रित toolset दोनों नामों को {server_id}__{tool_name} के रूप में उपसर्ग करता है। अद्वितीय नाम अपरिवर्तित रहते हैं।

स्वास्थ्य मॉनिटर एक बंद MCP कनेक्शन का पता लगाता है। एक कॉन्फ़िगर किया गया RestartPolicy घातीय बैकऑफ़ के साथ बाउंडेड रिट्री को नियंत्रित करता है। यह कनेक्शन पर्यवेक्षण है, न कि एप्लिकेशन-स्तरीय स्वास्थ्य जांच: जब आपको सर्वर के बैकिंग डेटाबेस या बाहरी API को सत्यापित करने की आवश्यकता हो तो एक डोमेन tool या एक अलग सेवा जांच का उपयोग करें।

नियतात्मक उदाहरण चलाएँ:

cargo run --manifest-path examples/mcp_manager/Cargo.toml

यह एक वास्तविक Rust MCP चाइल्ड सर्वर शुरू करता है और डिस्कवरी, एक tool कॉल, रनटाइम add/enable/update/disable/remove, कॉन्फ़िग परसिस्टेंस और शटडाउन का अभ्यास करता है। यह पैकेज डाउनलोड नहीं करता है या API कुंजी की आवश्यकता नहीं होती है।

रिमोट Streamable HTTP

use adk_tool::{McpAuth, McpHttpClientBuilder};
use std::time::Duration;

let toolset = McpHttpClientBuilder::new("https://mcp.example.com/mcp")
    .with_auth(McpAuth::bearer(std::env::var("MCP_TOKEN")?))
    .header("X-Tenant-ID", "tenant-42")
    .timeout(Duration::from_secs(30))
    .reinit_on_expired_session(true)
    .connect()
    .await?;

बिल्डर अनुरोध टाइमआउट, कस्टम हेडर, बेयरर टोकन, कस्टम API-की हेडर और बाउंडेड रिकवरी लागू करता है जब एक HTTP सेशन समाप्त हो जाता है।

OAuth2Config एक निश्चित OAuth 2.0 client-credentials टोकन अनुरोध को लागू करता है। यह ज्ञात टोकन एंडपॉइंट वाले सर्वर के लिए उपयोगी है। यह पूर्ण MCP प्राधिकरण प्रवाह नहीं है: यह संरक्षित-resource मेटाडेटा डिस्कवरी, प्राधिकरण-सर्वर डिस्कवरी, ब्राउज़र प्राधिकरण, PKCE, या resource-indicator नेगोशिएशन नहीं करता है। जब डिप्लॉयमेंट को उस प्रवाह की आवश्यकता हो तो rmcp के प्राधिकरण APIs या एक बाहरी पहचान घटक का उपयोग करें।

Elicitation

एक MCP सर्वर को ऐसी जानकारी की आवश्यकता हो सकती है जो tool आर्ग्यूमेंट्स में शामिल नहीं थी। उस स्थिति में यह क्लाइंट को एक elicitation अनुरोध वापस भेज सकता है। एप्लिकेशन यह तय करता है कि अनुरोध को किसी व्यक्ति को कैसे दिखाया जाए और क्या इसे स्वीकार करना है, अस्वीकार करना है या रद्द करना है।

let toolset = McpToolset::with_elicitation_handler(
    transport,
    Arc::new(MyElicitationHandler),
).await?;

ADK-Rust form और URL elicitation दोनों का विज्ञापन करता है। एक हैंडलर त्रुटि या पैनिक को अस्वीकृति में बदल दिया जाता है ताकि MCP कनेक्शन उपयोग योग्य बना रहे। परिणामी अनुरोध स्वीकार करने से पहले एप्लिकेशन में लौटाए गए मानों को मान्य करें और सहमति नियमों को लागू करें।

एक पूर्ण सर्वर और इंटरैक्टिव क्लाइंट के लिए examples/mcp_elicitation देखें।

लंबे समय तक चलने वाले MCP कार्य

MCP 2025-11-25 एक tool कॉल को एक प्रोटोकॉल कार्य में ले जा सकता है। ADK-Rust कार्य प्रवाह का उपयोग केवल तभी करता है जब सर्वर ने tasks.requests.tools.call पर बातचीत की हो और tool ने आवश्यक या वैकल्पिक कार्य समर्थन घोषित किया हो।

use adk_tool::McpTaskConfig;
use std::time::Duration;

let toolset = McpToolset::new(client).with_task_support(
    McpTaskConfig::enabled()
        .poll_interval(Duration::from_secs(1))
        .timeout(Duration::from_secs(120))
        .max_attempts(120),
);

कार्य मोड के लिए, ADK-Rust:

1. आधिकारिक कार्य मेटाडेटा के साथ tools/call भेजता है;
2. बनाए गए कार्य को प्राप्त करता है;
3. सर्वर के सुझाए गए अंतराल का उपयोग करके tasks/get को पोल करता है;
4. tasks/result के माध्यम से अंतिम पेलोड पढ़ता है; और
5. जब इसकी स्थानीय टाइमआउट या पोल सीमा तक पहुँच जाती है तो tasks/cancel को कॉल करता है।

input_required को एक टाइप की गई त्रुटि के रूप में लौटाया जाता है क्योंकि एक साधारण ADK tool कॉल में अभी तक उस गुम इनपुट की आपूर्ति के लिए एक प्रोटोकॉल-न्यूट्रल रिज्यूम चैनल नहीं है। उस इंटरैक्शन को स्वामित्व वाले वर्कफ़्लो में स्पष्ट रूप से डिज़ाइन करें।

क्षमता मानचित्र

सीमा का चुनाव

क्षमता उसी प्रक्रिया और रिलीज़ से संबंधित होने पर Rust FunctionTool का उपयोग करें। जब कोई अन्य प्रोग्राम, टीम, भाषा, सुरक्षा सीमा, या डिप्लॉयमेंट क्षमता का मालिक हो और उसे अपना अनुबंध प्रकाशित करना चाहिए, तब MCP का उपयोग करें।

उत्पादन डिप्लॉयमेंट के लिए:

• सबसे छोटा उपयोगी टूल सेट उजागर करें;
• केवल पढ़ने योग्य और परिणामी कार्यों को अलग करें;
• कमांड-लाइन आर्ग्यूमेंट्स और कमिटेड mcp.json फ़ाइलों से रहस्यों को दूर रखें;
• रिमोट HTTP सर्वर को प्रमाणित करें और क्रेडेंशियल्स को संकीर्ण रूप से स्कोप करें;
• टूल विवरण और सर्वर-लौटाई गई सामग्री को अविश्वसनीय इनपुट के रूप में मानें;
• टूल निष्पादन के आसपास ADK-Rust प्राधिकरण और अनुमोदन बनाए रखें;
• कनेक्शन, टूल और कार्य टाइमआउट को सीमित करें; और
• टूल कॉल, अनुमोदन, त्रुटियों और सर्वर जीवनचक्र परिवर्तनों को रिकॉर्ड करें।

वर्तमान सीमाएँ

• McpServerManager स्थानीय stdio चाइल्ड प्रक्रियाओं का प्रबंधन करता है। रिमोट HTTP सेवाएँ McpHttpClientBuilder और एप्लिकेशन-स्वामित्व वाली कॉन्फ़िगरेशन का उपयोग करती हैं।
• मैनेजर स्वास्थ्य जांच बंद MCP कनेक्शन का पता लगाती है; वे व्यावसायिक-स्तर के स्वास्थ्य टूल को कॉल नहीं करती हैं।
• रजिस्ट्री म्यूटेशन तब क्रमबद्ध होते हैं जब एक चाइल्ड अपना MCP हैंडशेक पूरा करता है।
• autoApprove कॉन्फ़िगरेशन संगतता है, प्राधिकरण प्रवर्तन नहीं।
• बिल्ट-इन OAuth हेल्पर क्लाइंट क्रेडेंशियल्स है, न कि पूर्ण MCP OAuth खोज और उपयोगकर्ता-प्राधिकरण प्रवाह।

ये सीमाएँ इसलिए बताई गई हैं ताकि डिप्लॉयमेंट के निर्णय स्पष्ट रहें।

संदर्भ

• MCP स्पेसिफिकेशन 2025-11-25
• आधिकारिक Rust SDK (rmcp)
• rmcp 2.2 API डॉक्यूमेंटेशन
• प्रदाता-जागरूक स्कीमा सामान्यीकरण