एक ही MCP सर्वर दो बार बनाएँ, C# में आधिकारिक NuGet पैकेज से और Java में Spring AI से। एक वर्ड काउंटर और PicassoIA API को कॉल करने वाला एक इमेज टूल जोड़ें, stdio या HTTP चुनें, फिर MCP Inspector और एक असली AI क्लाइंट से टेस्ट करें।
MCP सर्वर एक छोटा प्रोग्राम है जो JSON-RPC मैसेज का इंतज़ार करता है, एक फ़ंक्शन चलाता है और नतीजा वापस AI क्लाइंट को भेजता है। बस इतना ही है। C# और Java में यह भारी लगता है क्योंकि दोनों इकोसिस्टम में प्रोजेक्ट टेम्पलेट, डिपेंडेंसी इंजेक्शन, एनोटेशन और बिल्ड टूल्स आते हैं। यह ट्यूटोरियल इसी उलझन को हटाता है। आप दो ही टूल दो बार बनाएँगे, एक बार C# में आधिकारिक ModelContextProtocol NuGet पैकेज से और एक बार Java में Spring AI के MCP स्टार्टर से, फिर दोनों को MCP Inspector से टेस्ट करेंगे और एक असली क्लाइंट से जोड़ेंगे।
दोनों टूल जानबूझकर छोटे रखे गए हैं। word_count यह साबित करता है कि कनेक्शन का ढाँचा काम करता है, और generate_image PicassoIA API को कॉल करता है, ताकि Claude जैसा AI क्लाइंट आपके कोड से एक तस्वीर माँग सके और उसका लिंक वापस पा सके। कोड आधिकारिक SDK डॉक्यूमेंटेशन का पालन करता है, लेकिन अपने पैकेज वर्ज़न खुद पिन करें और भरोसा करने से पहले टेस्टिंग सेक्शन की जाँच चलाएँ।
Model Context Protocol एक ओपन स्टैंडर्ड है जो किसी AI एप्लिकेशन (क्लाइंट) को बाहरी प्रोग्राम्स (सर्वर) से एक सुसंगत तरीके से बात करने देता है। क्लाइंट कनेक्ट होता है, सर्वर से पूछता है कि वह क्या कर सकता है, और जब मॉडल को ज़रूरत लगती है तब उन क्षमताओं को कॉल करता है। आपका सर्वर मॉडल से सीधे बात नहीं करता। वह अनुरोधों का जवाब देता है, और बातचीत क्लाइंट संभालता है।
एक सर्वर तीन तरह की क्षमताएँ दे सकता है:
generate_image या word_count। हर एक का एक नाम, एक विवरण और इनपुट के लिए एक JSON स्कीमा होता है।ज़्यादातर सर्वर केवल टूल्स भेजते हैं, और यही ट्यूटोरियल बनाता है। हर टूल के लिए आप जो विवरण लिखते हैं वह अंदर के कोड से ज़्यादा मायने रखता है, क्योंकि मॉडल यही टेक्स्ट पढ़कर तय करता है कि उसे कब कॉल करना है।
💡 टिप: टूल का विवरण ऐसे लिखें जैसे किसी नए सहकर्मी को ब्रीफ़ कर रहे हों। बताएँ कि टूल क्या करता है, उसे क्या चाहिए और वह क्या लौटाता है।
दोनों SDK JSON-RPC की बारीकियाँ छिपा देते हैं। आप एक मेथड घोषित करते हैं, उसके पैरामीटर बताते हैं, और लाइब्रेरी स्कीमा बनाती है और अनुरोध का चक्र संभालती है। दोनों टूल्स के सेट ऐसे मेल खाते हैं:
| पहलू | C# | Java |
|---|---|---|
| मुख्य पैकेज | ModelContextProtocol | io.modelcontextprotocol.sdk:mcp या Spring AI स्टार्टर्स |
| टूल घोषित करें | [McpServerTool] एट्रिब्यूट | @Tool एनोटेशन (Spring AI) |
| Stdio ट्रांसपोर्ट | WithStdioServerTransport() | spring-ai-starter-mcp-server |
| HTTP ट्रांसपोर्ट | ModelContextProtocol.AspNetCore | spring-ai-starter-mcp-server-webmvc या -webflux |
| रनटाइम | .NET SDK | Java 17 या नया |
C# SDK Microsoft के सहयोग से बनाया और रखा जाता है, और Java SDK के Spring इंटीग्रेशन अब Spring AI में हैं। दोनों में आप एनोटेशन और डिपेंडेंसी इंजेक्शन के साथ काम करते हैं, इसलिए कोड उस भाषा की किसी भी दूसरी सर्विस जैसा पढ़ा जाता है।
ज़रूरी चीज़ें एक बार इंस्टॉल कर लें, फिर दोनों बिल्ड एक ही लैपटॉप पर चल जाएँगे। आपको Node.js भी चाहिए, क्योंकि MCP Inspector npx के ज़रिए चलता है।
.NET SDK इंस्टॉल करें और dotnet --version से जाँच लें। NuGet पर ModelContextProtocol पैकेज का पेज देखें कि वह कम से कम कौन सा फ़्रेमवर्क लक्ष्य करता है, फिर ऐसा SDK चुनें जो उसे पूरा करे। कोड एडिटर मददगार है, पर इस प्रोजेक्ट के लिए सादा टर्मिनल भी काफ़ी है।
JDK 17 या नया इंस्टॉल करें, साथ में Maven या Gradle। Java SDK का बेसलाइन Java 17 बताया गया है। यह ट्यूटोरियल Maven और Spring Boot प्रोजेक्ट इस्तेमाल करता है, क्योंकि Spring AI स्टार्टर उस ट्रांसपोर्ट कोड का ज़्यादातर हिस्सा हटा देता है जो आपको हाथ से लिखना पड़ता।
दोनों सर्वर PicassoIA क्रेडेंशियल एक एनवायरनमेंट वेरिएबल से पढ़ते हैं। picassoia.com/en/api पर API टोकन बनाएँ (यह pia_sk_ से शुरू होता है) और इसे PICASSOIA_API_TOKEN के रूप में एक्सपोर्ट करें। इसे कभी सोर्स कोड में न डालें, और PicassoIA प्राइसिंग पेज देखें कि कौन से प्लान API एक्सेस शामिल करते हैं।
एक खाली फ़ोल्डर में ये कमांड चलाएँ:
dotnet new console -n PicassoMcp
cd PicassoMcp
dotnet add package ModelContextProtocol
dotnet add package Microsoft.Extensions.Hosting
फिर Program.cs की सामग्री बदल दें:
using System.Net.Http.Headers;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
var builder = Host.CreateApplicationBuilder(args);
// Standard output carries the protocol, so every log line goes to standard error.
builder.Logging.AddConsole(options =>
{
options.LogToStandardErrorThreshold = LogLevel.Trace;
});
builder.Services.AddSingleton(_ =>
{
var client = new HttpClient { BaseAddress = new Uri("https://api.picassoia.com/v1/") };
var token = Environment.GetEnvironmentVariable("PICASSOIA_API_TOKEN");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
return client;
});
builder.Services
.AddMcpServer()
.WithStdioServerTransport()
.WithToolsFromAssembly();
await builder.Build().RunAsync();
दो बातों पर ध्यान दें। लॉगर सब कुछ स्टैंडर्ड एरर पर भेजता है, क्योंकि स्टैंडर्ड आउटपुट प्रोटोकॉल का है। और WithToolsFromAssembly() आपके प्रोजेक्ट में उन क्लासेज़ को खोजता है जिन्हें टूल टाइप मार्क किया गया है, इसलिए आपको टूल हाथ से रजिस्टर नहीं करने पड़ते।
Program.cs के बगल में PicassoTools.cs बनाएँ। सरल टूल से शुरू करें:
using System.ComponentModel;
using ModelContextProtocol.Server;
[McpServerToolType]
public static class PicassoTools
{
[McpServerTool(Name = "word_count")]
[Description("Counts the words in a piece of text and returns the number.")]
public static int WordCount([Description("The text to count")] string text) =>
// A null separator splits on any whitespace.
text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries).Length;
}
तीनों एट्रिब्यूट सारा काम करते हैं। [McpServerToolType] क्लास को मार्क करता है, [McpServerTool] मेथड को, और हर [Description] वह टेक्स्ट बन जाता है जिसे मॉडल पढ़ता है। पैरामीटर के नाम और टाइप अपने-आप इनपुट स्कीमा बन जाते हैं।
PicassoIA API असिंक्रोनस है और Replicate पैटर्न का पालन करता है। आप POST /v1/models/{owner}/{name}/predictions से प्रेडिक्शन बनाते हैं, फिर स्टेटस succeeded होने तक GET /v1/predictions/{id} को पोल करते हैं। ऑथेंटिकेशन बेयरर टोकन से होता है, और एक अकाउंट एक साथ 5 प्रेडिक्शन चला सकता है। फ़ाइल के ऊपर अतिरिक्त using लाइनों के साथ, इसी क्लास के अंदर यह मेथड जोड़ें:
using System.Net.Http.Json;
using System.Text.Json;
using ModelContextProtocol;
[McpServerTool(Name = "generate_image")]
[Description("Generates an image with PicassoIA and returns the finished prediction as JSON.")]
public static async Task<string> GenerateImage(
HttpClient client,
[Description("What the image should show")] string prompt,
[Description("Aspect ratio such as 16:9 or 1:1")] string aspectRatio = "16:9",
CancellationToken cancellationToken = default)
{
var created = await client.PostAsJsonAsync(
"models/picassoia/picassoia-image/predictions",
new { input = new { prompt, aspect_ratio = aspectRatio } },
cancellationToken);
created.EnsureSuccessStatusCode();
using var createdDoc = JsonDocument.Parse(
await created.Content.ReadAsStringAsync(cancellationToken));
var id = createdDoc.RootElement.GetProperty("id").GetString();
while (true)
{
await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
var json = await client.GetStringAsync($"predictions/{id}", cancellationToken);
using var doc = JsonDocument.Parse(json);
var status = doc.RootElement.GetProperty("status").GetString();
if (status == "succeeded") return json;
if (status is "failed" or "canceled")
throw new McpException($"The generation ended with status '{status}'.");
}
}
HttpClient पैरामीटर डिपेंडेंसी इंजेक्शन से हल होता है, इसलिए Program.cs में कॉन्फ़िगर किया गया टोकन उसके साथ चलता है। क्योंकि मेथड एक CancellationToken स्वीकार करता है, क्लाइंट धीमी जनरेशन को रद्द कर सकता है, बजाय इसके कि वह लटकी रहे। इस कॉल के पीछे का मॉडल PicassoIA Image है, और यही पैटर्न API द्वारा दिए गए बाकी मॉडलों पर भी काम करता है।
Java वर्ज़न में वही दो टूल और वही व्यवहार है। बदलती है केवल पैकेजिंग।
एक Spring Boot प्रोजेक्ट बनाएँ और Spring AI का बिल ऑफ़ मटीरियल्स इम्पोर्ट करें, फिर stdio स्टार्टर जोड़ें:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>${spring-ai.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-mcp-server</artifactId>
</dependency>
</dependencies>
spring-ai.version को अपनी पसंद के रिलीज़ पर सेट करें। फिर src/main/resources/application.properties जोड़ें:
spring.main.web-application-type=none
spring.main.banner-mode=off
logging.pattern.console=
spring.ai.mcp.server.name=picassoia-java
spring.ai.mcp.server.version=1.0.0
पहली तीन लाइनें डिपेंडेंसी जितनी ही मायने रखती हैं। ये वेब सर्वर, स्टार्टअप बैनर और कंसोल लॉग पैटर्न बंद कर देती हैं, क्योंकि स्टैंडर्ड आउटपुट पर छपी कोई भी चीज़ stdio स्ट्रीम तोड़ देती है।
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
@Service
public class PicassoTools {
private final RestClient client;
public PicassoTools(RestClient.Builder builder,
@Value("${PICASSOIA_API_TOKEN}") String token) {
this.client = builder
.baseUrl("https://api.picassoia.com/v1")
.defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer " + token)
.build();
}
@Tool(description = "Counts the words in a piece of text and returns the number.")
public int wordCount(@ToolParam(description = "The text to count") String text) {
return text.isBlank() ? 0 : text.trim().split("\\s+").length;
}
@Tool(description = "Generates an image with PicassoIA and returns the finished prediction.")
public Map<String, Object> generateImage(
@ToolParam(description = "What the image should show") String prompt,
@ToolParam(description = "Aspect ratio such as 16:9 or 1:1", required = false)
String aspectRatio) throws InterruptedException {
String ratio = aspectRatio == null ? "16:9" : aspectRatio;
Map<String, Object> created = client.post()
.uri("/models/picassoia/picassoia-image/predictions")
.contentType(MediaType.APPLICATION_JSON)
.body(Map.of("input", Map.of("prompt", prompt, "aspect_ratio", ratio)))
.retrieve()
.body(new ParameterizedTypeReference<>() {});
String id = (String) created.get("id");
for (int attempt = 0; attempt < 60; attempt++) {
Thread.sleep(5000);
Map<String, Object> prediction = client.get()
.uri("/predictions/{id}", id)
.retrieve()
.body(new ParameterizedTypeReference<>() {});
String status = (String) prediction.get("status");
if ("succeeded".equals(status)) return prediction;
if ("failed".equals(status) || "canceled".equals(status)) {
throw new IllegalStateException("The generation ended with status " + status);
}
}
throw new IllegalStateException("The generation took longer than five minutes.");
}
}
@Tool और @ToolParam वही भूमिका निभाते हैं जो C# एट्रिब्यूट निभाते हैं। Spring इन्हें टूल का नाम, विवरण और इनपुट स्कीमा बना देता है। मेथड एक Map लौटाता है। Spring AI उसे क्लाइंट के लिए JSON में बदल देता है।
एनोटेट किए गए मेथड तब तक उजागर नहीं होते जब तक आप उन्हें रजिस्टर न करें। अपनी मेन क्लास में एक बीन जोड़ें:
@SpringBootApplication
public class PicassoMcpApplication {
public static void main(String[] args) {
SpringApplication.run(PicassoMcpApplication.class, args);
}
@Bean
ToolCallbackProvider picassoTools(PicassoTools tools) {
return MethodToolCallbackProvider.builder().toolObjects(tools).build();
}
}
mvn package से बिल्ड करें और आपको एक चलने योग्य JAR मिल जाएगा।
अगर आपके प्रोजेक्ट में Spring नहीं है, तो io.modelcontextprotocol.sdk:mcp पर निर्भर रहें और मॉड्यूल वर्ज़न एक जैसे रखने के लिए mcp-bom इम्पोर्ट करें। सर्वर स्वयं कुछ ही लाइनों का है:
StdioServerTransportProvider transport =
new StdioServerTransportProvider(McpJsonDefaults.getMapper());
McpSyncServer server = McpServer.sync(transport)
.serverInfo("picassoia-java", "1.0.0")
.capabilities(ServerCapabilities.builder().tools(true).build())
.build();
यह स्निपेट SDK की 2.0 लाइन का पालन करता है। आप हर टूल को SyncToolSpecification के रूप में जोड़ते हैं, जिसमें नाम, विवरण, JSON स्कीमा और कॉल हैंडलर होता है। ट्रांसपोर्ट कंस्ट्रक्टर जैसे बिल्डर के ब्यौरे रिलीज़ के बीच अलग होते हैं, इसलिए अपने वर्ज़न से मेल खाते README से टूल वाला स्निपेट कॉपी करें। Spring उपयोगकर्ताओं को यह सब मुफ़्त मिल जाता है, इसलिए स्टार्टर छोटा रास्ता है।
ट्रांसपोर्ट तय करता है कि आपके सर्वर को कौन चलाएगा और उस तक कौन पहुँच सकता है।
| ट्रांसपोर्ट | सबसे अच्छा किसके लिए | C# | Java |
|---|---|---|---|
| Stdio | क्लाइंट द्वारा चलाए गए लोकल टूल | WithStdioServerTransport() | spring-ai-starter-mcp-server |
| HTTP | रिमोट या साझा सर्वर | WithHttpTransport() और MapMcp() | WebMVC या WebFlux स्टार्टर |
Stdio में क्लाइंट आपकी प्रोसेस शुरू करता है और स्टैंडर्ड इनपुट व आउटपुट के ज़रिए उससे बात करता है। यह सबसे सरल विकल्प है और कुछ भी नेटवर्क पर उजागर नहीं होता, इसलिए यहीं से शुरू करें। HTTP में एक डिप्लॉयमेंट कई क्लाइंट्स को सेवा देता है, यानी ऑथेंटिकेशन, TLS और रेट लिमिट अब आपकी ज़िम्मेदारी हैं।
C# में HTTP पर जाने के लिए ModelContextProtocol.AspNetCore पैकेज जोड़ें और होस्ट बदलें:
var builder = WebApplication.CreateBuilder(args);
builder.Services
.AddMcpServer()
.WithHttpTransport()
.WithToolsFromAssembly();
var app = builder.Build();
app.MapMcp();
app.Run();
Java में स्टार्टर बदलकर spring-ai-starter-mcp-server-webmvc लगाएँ, या रिऐक्टिव ऐप्स के लिए WebFlux वेरिएंट। Spring AI डॉक्यूमेंटेशन /sse और /mcp/message को डिफ़ॉल्ट एंडपॉइंट बताता है, और stdio को HTTP के साथ चलाने के लिए spring.ai.mcp.server.stdio=true बताता है।
⚠️ चेतावनी: जो HTTP सर्वर किसी पेड या रेट-लिमिटेड API को कॉल करने वाला टूल चलाता है, उसे इंटरनेट तक पहुँचने से पहले ऑथेंटिकेशन चाहिए। जो भी एंडपॉइंट तक पहुँच सकता है, वह टूल को कॉल कर सकता है।
Inspector एक ब्राउज़र टूल है जो आपके सर्वर से कनेक्ट होता है, उसके टूल्स की सूची दिखाता है और आपको हाथ से टाइप किए आर्गुमेंट्स से उन्हें कॉल करने देता है। पहले बिल्ड करें, फिर अपने सर्वर कमांड से उसे लॉन्च करें:
dotnet build
npx @modelcontextprotocol/inspector dotnet run --project ./PicassoMcp --no-build
npx @modelcontextprotocol/inspector java -jar target/picassoia-mcp-0.0.1.jar
कनेक्ट करें, Tools टैब खोलें और टूल्स की सूची देखें। आपको word_count और generate_image दिखने चाहिए, हर एक के साथ आपका लिखा विवरण। word_count को one two three के साथ कॉल करें और 3 की उम्मीद करें। फिर एक छोटे प्रॉम्प्ट के साथ generate_image को कॉल करें और प्रेडिक्शन JSON वापस आने का इंतज़ार करें।
Claude Code में एक कमांड से C# सर्वर रजिस्टर होता है:
claude mcp add picassoia-dotnet -e PICASSOIA_API_TOKEN=pia_sk_your_token -- dotnet run --project ./PicassoMcp --no-build
Claude Desktop इसके बजाय एक JSON फ़ाइल पढ़ता है। claude_desktop_config.json में दोनों सर्वर जोड़ें:
{
"mcpServers": {
"picassoia-dotnet": {
"command": "dotnet",
"args": ["run", "--project", "C:/work/PicassoMcp", "--no-build"],
"env": { "PICASSOIA_API_TOKEN": "pia_sk_your_token" }
},
"picassoia-java": {
"command": "java",
"args": ["-jar", "C:/work/picassoia-mcp/target/picassoia-mcp-0.0.1.jar"],
"env": { "PICASSOIA_API_TOKEN": "pia_sk_your_token" }
}
}
}
क्लाइंट को रीस्टार्ट करें और उससे पूछें "सूर्यास्त के समय एक लाइटहाउस की 16:9 फ़ोटो बनाओ"। उसे आपका टूल कॉल करना चाहिए और इमेज लिंक के साथ प्रेडिक्शन लौटाना चाहिए।
Console.WriteLine या System.out.println JSON-RPC स्ट्रीम को खराब कर देता है। लॉग केवल स्टैंडर्ड एरर पर करें।कॉन्करेंसी की सीमा भी याद रखें। हर अकाउंट के लिए एक साथ 5 प्रेडिक्शन की अनुमति है, इसलिए जो क्लाइंट एक साथ बहुत सारी generate_image कॉल भेज देता है, उसे त्रुटियाँ दिखने लगेंगी। इसलिए कॉल्स को कतार में लगाएँ या साफ़ संदेश लौटाएँ।
बॉयलरप्लेट लिखने में यहाँ AI मॉडल सबसे ज़्यादा समय बचाता है, और PicassoIA पर Claude Sonnet 5 कोडिंग और मल्टी-स्टेप टूल-यूज़ कामों के लिए बना है। नए टूल का ड्राफ़्ट बनाने में इसका इस्तेमाल करें, फिर हर API नाम को SDK डॉक्यूमेंटेशन से मिलाकर जाँचें।
[McpServerTool] और [Description] एट्रिब्यूट इस्तेमाल करें" हर जवाब को एक जैसा रखता है।low पर रखें। जब कोड कई फ़ाइलों को छूता हो या बग ज़िद्दी हो, तब high या max पर ले जाएँ।| सेटिंग | डिफ़ॉल्ट | कब बदलें |
|---|---|---|
effort | low | काम को गहरी रीज़निंग चाहिए |
max_tokens | 8192 | जवाब बीच में कट जाए |
system_prompt | खाली | आप एक तय कोडिंग स्टाइल या भूमिका चाहते हैं |
image | कोई नहीं | आप स्क्रीनशॉट या डायग्राम साझा करना चाहते हैं |
उसी प्रॉम्प्ट पर दूसरी राय चाहिए तो Claude Fable 5, GPT 5.6 Sol या Kimi K2.6 का आउटपुट तुलना के लिए देखें।
अब आपके पास दो काम करने वाले सर्वर हैं जो इमेज जनरेशन को AI क्लाइंट को सौंपते हैं। अगला कदम यह देखना है कि उनके पीछे का मॉडल अपने दम पर क्या कर सकता है। PicassoIA Image खोलें, वही प्रॉम्प्ट टाइप करें जो आपने अपने टूल से भेजा था, और नतीजे की तुलना करें। फिर आस्पेक्ट रेशियो बदलें, रोशनी दोबारा लिखें और एक सीन के तीन वेरिएशन आज़माएँ। जब कोई रेंडर लगभग सही हो पर पूरी तरह न हो, तो उसे PicassoIA Image Editor Pro में भेजें और शुरू से दोबारा करने के बजाय विवरण ठीक करें।
Picasso IA पर प्रॉम्प्ट्स के साथ जितना ज़्यादा प्रयोग करेंगे, आपके टूल के विवरण और डिफ़ॉल्ट आर्गुमेंट उतने ही बेहतर होंगे। आज अपनी पहली इमेज बनाएँ, फिर सबसे अच्छा प्रॉम्प्ट अपने सर्वर में जोड़ें और बाकी काम अपने AI क्लाइंट पर छोड़ दें।
अपनी भाषा चुनें
