Rust 기반 MCP 서버 구축하기: ZeroClaw 아키텍처 활용

[dependencies]
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
async-trait = "0.1"

use serde_json::Value;
use async_trait::async_trait;

#[async_trait]
pub trait McpHandler {
    async fn handle(&self, params: Value) -> Result<Value, String>;
    fn name(&self) -> &str;
}

use std::fs;
use std::path::Path;

pub struct LogReaderTool;

#[async_trait]
impl McpHandler for LogReaderTool {
    fn name(&self) -> &str {
        "read_logs"
    }

    async fn handle(&self, params: Value) -> Result<Value, String> {
        // 1. 파라미터 검증 및 추출
        let file_path = params.get("path")
            .and_then(|v| v.as_str())
            .ok_or("Missing 'path' parameter".to_string())?;

        // 2. 보상: 경로 조작 방지 (SandBoxing)
        // 실제 운영 환경에서는 chroot나 전용 가상 디렉토리를 사용해야 합니다.
        if !file_path.ends_with(".log") {
            return Err("Only .log files are allowed".into());
        }

        // 3. 파일 시스템 접근 (동기식 I/O를 비동기 컨텍스트로 래핑)
        let content = fs::read_to_string(file_path)
            .map_err(|e| format!("Failed to read file: {}", e))?;

        // 4. 결과 포맷팅
        Ok(serde_json::json!({
            "status": "success",
            "content": content,
            "lines": content.lines().count()
        }))
    }
}

use tokio::io::{AsyncBufReadExt, BufReader};
use tokio::io::{AsyncWriteExt, BufWriter};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let stdin = tokio::io::stdin();
    let stdout = tokio::io::stdout();
    let mut reader = BufReader::new(stdin).lines();
    let mut writer = BufWriter::new(stdout);

    let tool = Arc::new(LogReaderTool);

    // LLM이나 호스트로부터 요청이 들어올 때마다 처리
    while let Ok(Some(line)) = reader.next_line().await {
        if line.trim().is_empty() { continue; }

        if let Ok(json_req) = serde_json::from_str::<Value>(&line) {
            let method = json_req.get("method").and_then(|m| m.as_str()).unwrap_or("");
            let id = json_req.get("id");

            if method == "tools/call" || method == "tools/invoke" {
                let params = json_req.get("params").cloned().unwrap_or(Value::Null);
                
                // 비즈니스 로직 실행
                let result = tool.handle(params).await;
                
                let response = match result {
                    Ok(data) => serde_json::json!({
                        "jsonrpc": "2.0",
                        "id": id,
                        "result": data
                    }),
                    Err(e) => serde_json::json!({
                        "jsonrpc": "2.0",
                        "id": id,
                        "error": { "code": -32000, "message": e }
                    })
                };
                
                writer.write_all(response.to_string().as_bytes()).await?;
                writer.write_all(b"\n").await?;
                writer.flush().await?;
            }
        }
    }
    Ok(())
}