TurboMCP

use turbomcp::prelude::*;

#[derive(Clone)]
struct HelloServer;

#[server(name = "hello", version = "1.0.0")]
impl HelloServer {
    #[tool("Say hello to someone")]
    async fn hello(&self, name: String) -> McpResult<String> {
        Ok(format!("Hello, {}!", name))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    HelloServer.run_stdio().await?;
    Ok(())
}

// That's it! Just 25 lines for a complete MCP server.
// JSON schemas automatically generated from function signatures.

use turbomcp::prelude::*;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

#[derive(Clone)]
struct KnowledgeServer {
    documents: Arc<RwLock<HashMap<String, String>>>,
}

#[server(
    name = "KnowledgeBase",
    version = "2.0.0",
    root = "file:///docs:Documentation"
)]
impl KnowledgeServer {
    #[tool("Store a document in the knowledge base")]
    async fn store_document(
        &self,
        ctx: Context,
        name: String,
        content: String,
    ) -> McpResult<String> {
        ctx.info(&format!("Storing document: {}", name)).await?;

        let mut docs = self.documents.write().await;
        docs.insert(name.clone(), content.clone());

        Ok(format!("Stored {} ({} chars)", name, content.len()))
    }

    #[resource("kb://docs/{name}")]
    async fn get_document(&self, name: String) -> McpResult<String> {
        let docs = self.documents.read().await;
        docs.get(&name)
            .cloned()
            .ok_or_else(|| mcp_error!("Document not found: {}", name))
    }

    #[prompt("Generate documentation")]
    async fn doc_prompt(
        &self,
        project_type: String,
        description: String,
    ) -> McpResult<String> {
        Ok(format!(
            "Generate comprehensive docs for {} project:\n{}",
            project_type, description
        ))
    }
}

use turbomcp::prelude::*;

#[server(name = "SafeCalculator", version = "2.0.0")]
impl Calculator {
    #[tool("Safe division with validation")]
    async fn divide(
        &self,
        ctx: Context,
        dividend: f64,
        divisor: f64,
    ) -> McpResult<f64> {
        // Context provides logging and tracing
        ctx.info(&format!("Division: {} / {}", dividend, divisor))
            .await?;

        // Validation with helpful error messages
        if divisor == 0.0 {
            return Err(McpError::invalid_request(
                "Division by zero is not allowed"
            ));
        }

        if dividend.is_infinite() || divisor.is_infinite() {
            return Err(McpError::invalid_request(
                "Cannot divide infinite numbers"
            ));
        }

        Ok(dividend / divisor)
    }

    #[tool("Power with range validation")]
    async fn power(&self, base: f64, exponent: f64) -> McpResult<f64> {
        // Prevent extremely large calculations
        if !(-1000.0..=1000.0).contains(&exponent) {
            return Err(McpError::invalid_request(
                "Exponent too large (limit: ±1000)"
            ));
        }

        let result = base.powf(exponent);

        if result.is_infinite() || result.is_nan() {
            return Err(McpError::invalid_request(
                "Result is not a valid number"
            ));
        }

        Ok(result)
    }
}