fix: replace println! with eprintln! in all MCP server examples for stdio transport compliance

Author: cablehead

src/examples/example_01_hello_world.rs

@@ -152,11 +152,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize logging to help with debugging
     tracing_subscriber::fmt::init();
 
-    println!("🚀 Starting Hello World MCP Server");
-    println!("📝 Available tools: greeting");
-    println!("💡 Send JSON-RPC messages via stdin");
-    println!("📋 Example: {{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\"}}");
-    println!();
+    eprintln!("🚀 Starting Hello World MCP Server");
+    eprintln!("📝 Available tools: greeting");
+    eprintln!("💡 Send JSON-RPC messages via stdin");
+    eprintln!("📋 Example: {{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\"}}");
+    eprintln!();
 
     // Create our server handler instance
     let server = HelloWorldServer::new();
@@ -204,6 +204,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    println!("👋 Hello World server shutting down");
+    eprintln!("👋 Hello World server shutting down");
     Ok(())
 }

src/examples/example_02_calculator.rs

@@ -204,11 +204,11 @@ impl CalculatorServer {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt::init();
 
-    println!("🧮 Starting Calculator MCP Server");
-    println!("📝 Available tools: calculator");
-    println!("💡 Send JSON-RPC messages via stdin");
-    println!("📋 Example: {{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{{\"name\":\"calculator\",\"arguments\":{{\"operation\":\"add\",\"a\":5,\"b\":3}}}}}}");
-    println!();
+    eprintln!("🧮 Starting Calculator MCP Server");
+    eprintln!("📝 Available tools: calculator");
+    eprintln!("💡 Send JSON-RPC messages via stdin");
+    eprintln!("📋 Example: {{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{{\"name\":\"calculator\",\"arguments\":{{\"operation\":\"add\",\"a\":5,\"b\":3}}}}}}");
+    eprintln!();
 
     let server = CalculatorServer::new();
 
@@ -254,7 +254,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    println!("🧮 Calculator server shutting down");
+    eprintln!("🧮 Calculator server shutting down");
     Ok(())
 }
 

src/examples/example_03_text_processor.rs

@@ -164,15 +164,15 @@ impl TextProcessorServer {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt::init();
 
-    println!("📝 Starting Text Processor MCP Server");
-    println!("🛠️  Available tools: transform_text, analyze_text");
-    println!("💡 Send JSON-RPC messages via stdin");
+    eprintln!("📝 Starting Text Processor MCP Server");
+    eprintln!("🛠️  Available tools: transform_text, analyze_text");
+    eprintln!("💡 Send JSON-RPC messages via stdin");
 
     // Simple demo mode for testing
     let server = TextProcessorServer::new();
 
     // Demo usage
-    println!("\n🧪 Running demo transformations:");
+    eprintln!("\n🧪 Running demo transformations:");
 
     let demo_text = "hello world";
     let transform_args = serde_json::json!({
@@ -183,12 +183,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     match server.call_tool("transform_text", transform_args) {
         Ok(result) => {
             let response: TextResponse = serde_json::from_value(result).unwrap();
-            println!(
+            eprintln!(
                 "✅ Transform '{}' to uppercase: '{}'",
                 demo_text, response.result
             );
         }
-        Err(e) => println!("❌ Transform failed: {}", e),
+        Err(e) => eprintln!("❌ Transform failed: {}", e),
     }
 
     let analyze_args = serde_json::json!({
@@ -198,15 +198,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     match server.call_tool("analyze_text", analyze_args) {
         Ok(result) => {
             let response: TextAnalysisResponse = serde_json::from_value(result).unwrap();
-            println!(
+            eprintln!(
                 "✅ Analysis of '{}': {} words, {} chars",
                 demo_text, response.word_count, response.character_count
             );
         }
-        Err(e) => println!("❌ Analysis failed: {}", e),
+        Err(e) => eprintln!("❌ Analysis failed: {}", e),
     }
 
-    println!("\n🎉 Text processor demo completed");
+    eprintln!("\n🎉 Text processor demo completed");
     Ok(())
 }
 

src/examples/example_04_simple_client.rs

@@ -44,19 +44,19 @@ impl SimpleMcpClient {
 
     // Simulate connecting to an MCP server
     pub async fn connect(&self) -> Result<(), String> {
-        println!("🔗 Connecting to MCP server: {}", self.server_url);
+        eprintln!("🔗 Connecting to MCP server: {}", self.server_url);
 
         // In a real implementation, this would establish a connection
         // For this demo, we'll just simulate success
         tokio::time::sleep(std::time::Duration::from_millis(100)).await;
 
-        println!("✅ Connected successfully!");
+        eprintln!("✅ Connected successfully!");
         Ok(())
     }
 
     // Simulate listing available tools from the server
     pub async fn list_tools(&self) -> Result<Vec<ToolInfo>, String> {
-        println!("🔍 Discovering available tools...");
+        eprintln!("🔍 Discovering available tools...");
 
         // Simulate network delay
         tokio::time::sleep(std::time::Duration::from_millis(50)).await;
@@ -101,17 +101,17 @@ impl SimpleMcpClient {
             },
         ];
 
-        println!("📋 Found {} tools", tools.len());
+        eprintln!("📋 Found {} tools", tools.len());
         for tool in &tools {
-            println!("  - {}: {}", tool.name, tool.description);
+            eprintln!("  - {}: {}", tool.name, tool.description);
         }
 
         Ok(tools)
     }
 
     // Simulate calling a tool on the server
     pub async fn call_tool(&self, request: ToolCallRequest) -> Result<ToolCallResponse, String> {
-        println!("🔧 Calling tool: {}", request.tool_name);
+        eprintln!("🔧 Calling tool: {}", request.tool_name);
 
         // Simulate network delay
         tokio::time::sleep(std::time::Duration::from_millis(100)).await;
@@ -216,8 +216,8 @@ impl SimpleMcpClient {
 
     // Demonstrate a complete client workflow
     pub async fn demonstrate_client_workflow(&self) -> Result<(), String> {
-        println!("🚀 Starting MCP Client Demonstration");
-        println!("====================================");
+        eprintln!("🚀 Starting MCP Client Demonstration");
+        eprintln!("====================================");
 
         // Step 1: Connect to server
         self.connect().await?;
@@ -226,7 +226,7 @@ impl SimpleMcpClient {
         let tools = self.list_tools().await?;
 
         // Step 3: Call each tool with sample data
-        println!("\n🧪 Testing tools with sample data:");
+        eprintln!("\n🧪 Testing tools with sample data:");
 
         // Test greeting tool
         if tools.iter().any(|t| t.name == "greeting") {
@@ -241,16 +241,16 @@ impl SimpleMcpClient {
                     result: Some(result),
                     ..
                 } => {
-                    println!("✅ Greeting result: {}", result);
+                    eprintln!("✅ Greeting result: {}", result);
                 }
                 ToolCallResponse {
                     success: false,
                     error: Some(err),
                     ..
                 } => {
-                    println!("❌ Greeting failed: {}", err);
+                    eprintln!("❌ Greeting failed: {}", err);
                 }
-                _ => println!("⚠️  Unexpected greeting response"),
+                _ => eprintln!("⚠️  Unexpected greeting response"),
             }
         }
 
@@ -271,16 +271,16 @@ impl SimpleMcpClient {
                     result: Some(result),
                     ..
                 } => {
-                    println!("✅ Calculator result: {}", result);
+                    eprintln!("✅ Calculator result: {}", result);
                 }
                 ToolCallResponse {
                     success: false,
                     error: Some(err),
                     ..
                 } => {
-                    println!("❌ Calculator failed: {}", err);
+                    eprintln!("❌ Calculator failed: {}", err);
                 }
-                _ => println!("⚠️  Unexpected calculator response"),
+                _ => eprintln!("⚠️  Unexpected calculator response"),
             }
         }
 
@@ -300,20 +300,20 @@ impl SimpleMcpClient {
                     result: Some(result),
                     ..
                 } => {
-                    println!("✅ Text transform result: {}", result);
+                    eprintln!("✅ Text transform result: {}", result);
                 }
                 ToolCallResponse {
                     success: false,
                     error: Some(err),
                     ..
                 } => {
-                    println!("❌ Text transform failed: {}", err);
+                    eprintln!("❌ Text transform failed: {}", err);
                 }
-                _ => println!("⚠️  Unexpected text transform response"),
+                _ => eprintln!("⚠️  Unexpected text transform response"),
             }
         }
 
-        println!("\n🎉 Client demonstration completed successfully!");
+        eprintln!("\n🎉 Client demonstration completed successfully!");
         Ok(())
     }
 }

src/examples/example_05_resource_provider.rs

@@ -301,28 +301,28 @@ impl ResourceProviderServer {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing_subscriber::fmt::init();
 
-    println!("📚 Starting Resource Provider MCP Server");
-    println!("🗂️  Sample documents with search capabilities loaded");
-    println!();
+    eprintln!("📚 Starting Resource Provider MCP Server");
+    eprintln!("🗂️  Sample documents with search capabilities loaded");
+    eprintln!();
 
     let server = ResourceProviderServer::new();
 
     // Demonstrate resource functionality
-    println!("🧪 Demonstrating resource functionality:");
+    eprintln!("🧪 Demonstrating resource functionality:");
 
     // List resources
     let resources = server.list_resources();
-    println!("📋 Available resources ({} total):", resources.len());
+    eprintln!("📋 Available resources ({} total):", resources.len());
     for resource in &resources {
-        println!(
+        eprintln!(
             "  - {} ({})",
             resource.uri,
             resource.name.as_deref().unwrap_or("Unnamed")
         );
     }
 
     // Demonstrate search functionality
-    println!("\n🔍 Search demonstration:");
+    eprintln!("\n🔍 Search demonstration:");
     let search_args = serde_json::json!({
         "query": "Rust",
         "limit": 3
@@ -331,38 +331,38 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     match server.call_tool("search_documents", search_args) {
         Ok(result) => {
             let response: SearchResponse = serde_json::from_value(result).unwrap();
-            println!(
+            eprintln!(
                 "✅ Found {} documents matching 'Rust':",
                 response.total_count
             );
             for doc in response.matches {
-                println!("  - {}: {} [{}]", doc.id, doc.title, doc.tags.join(", "));
+                eprintln!("  - {}: {} [{}]", doc.id, doc.title, doc.tags.join(", "));
             }
         }
-        Err(e) => println!("❌ Search failed: {}", e),
+        Err(e) => eprintln!("❌ Search failed: {}", e),
     }
 
     // Demonstrate resource reading
-    println!("\n📖 Resource reading demonstration:");
+    eprintln!("\n📖 Resource reading demonstration:");
     match server.read_resource("document://doc1") {
         Ok(content) => {
-            println!("✅ Successfully read document://doc1");
+            eprintln!("✅ Successfully read document://doc1");
             let text = content
                 .get("contents")
                 .and_then(|c| c.as_array())
                 .and_then(|arr| arr.first())
                 .and_then(|item| item.get("text"))
                 .and_then(|t| t.as_str())
                 .unwrap_or("No content");
-            println!(
+            eprintln!(
                 "📄 Content preview: {}...",
                 &text[..std::cmp::min(text.len(), 100)]
             );
         }
-        Err(e) => println!("❌ Read failed: {}", e),
+        Err(e) => eprintln!("❌ Read failed: {}", e),
     }
 
-    println!("\n🎉 Resource provider demonstration completed!");
+    eprintln!("\n🎉 Resource provider demonstration completed!");
     Ok(())
 }