Struct McpAgent 

pub struct McpAgent { /* private fields */ }

McpAgent is an intelligent agent implementation based on MCP services It can connect to MCP servers, process user inputs, call tools, and generate responses

Implementations

impl McpAgent

pub fn new(client: Arc<dyn McpClient>, system_prompt: String) -> Self

Create a new McpAgent instance

pub fn with_openai_model( client: Arc<dyn McpClient>, system_prompt: String, openai_model: OpenAIChatModel, ) -> Self

Create a new McpAgent instance with specified OpenAIChatModel

pub fn with_memory( client: Arc<dyn McpClient>, system_prompt: String, memory: Box<dyn BaseMemory>, ) -> Self

Create a new McpAgent instance with specified memory module

pub fn with_openai_model_and_memory( client: Arc<dyn McpClient>, system_prompt: String, openai_model: OpenAIChatModel, memory: Box<dyn BaseMemory>, ) -> Self

Create a new McpAgent instance with specified OpenAIChatModel and memory module

Examples found in repository

examples/mcp_agent_client_chatbot.rs (lines 67-72)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();
    
    info!("=== Rust Agent MCP 客户端调用服务端工具示例 ===");
    
    // 从环境变量获取 MCP 服务器 URL
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://127.0.0.1:6000".to_string());
    
    // 创建 OpenAI 模型实例（可选，用于智能决策是否调用工具）
    // 如果没有设置 API 密钥，则使用一个占位符
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "sk-00000".to_string());
    let base_url = std::env::var("OPENAI_API_URL").unwrap_or("https://api.deepseek.com/v1".to_string());
    let model = OpenAIChatModel::new(api_key.clone(), Some(base_url))
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "deepseek-chat".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化 MCP 客户端
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 不添加任何本地工具，完全依赖服务端工具
    info!("Not adding any local tools, will use server-side tools only...");
    
    // 注意：客户端不需要实现工具处理器，因为工具实际在服务端执行
    // 客户端只需要知道工具的名称和描述即可
    
    // 连接到 MCP 服务器
    info!("正在连接到 MCP 服务器: {}", mcp_url);
    if let Err(e) = mcp_client.connect(&mcp_url).await {
        error!("连接到 MCP 服务器失败: {}", e);
        return;
    } else {
        mcp_client.set_server_connected(true);
    }
    info!("成功连接到 MCP 服务器");
    
    // let model_name = model.model_name().map_or("未指定模型".to_string(), |v| v.to_string());
    
    info!("----------------------------------------");
    
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    
    // 创建记忆模块实例
    let memory = SimpleMemory::new();

    // 创建 Agent 实例
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        "You are an AI assistant that can use tools to answer user questions. Please decide whether to use tools based on the user's needs.".to_string(),
        model.clone(),
        Box::new(memory.clone())
    );
    
    // 自动从 MCP 客户端获取工具并添加到 Agent
    if let Err(e) = agent.auto_add_tools().await {
        error!("自动添加工具到 Agent 失败: {}", e);
        return;
    }
    
    println!("MCP 客户端 Agent 已启动！");
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    
    // 获取并显示可用工具
    let tools = client_arc.get_tools().await.unwrap_or_else(|e| {
        error!("获取工具列表失败: {}", e);
        vec![]
    });
    
    println!("可用工具:");
    for (index, tool) in tools.iter().enumerate() {
        println!("{}. {}: {}", index + 1, tool.name, tool.description);
    }
    
    println!("----------------------------------------");
    
    // 演示直接调用工具
    println!("演示直接调用工具:");
    
    // 调用天气工具
    println!("\n1. 调用天气工具获取北京天气: What's the weather like in Beijing?");
    let mut weather_params = HashMap::new();
    weather_params.insert("city".to_string(), Value::String("Beijing".to_string()));
    
    match client_arc.call_tool("get_weather", weather_params).await {
        Ok(result) => {
            println!("天气查询结果: {}", serde_json::to_string_pretty(&result).unwrap_or_else(|_| "无法格式化结果".to_string()));
        },
        Err(e) => {
            println!("调用天气工具失败: {}", e);
        }
    }
    
    // 调用计算工具
    println!("\n2. 调用计算工具计算: 'What is 15.5 plus 24.3?'");
    let calc_params = json!({
        "expression": "15.5 + 24.3"
    });
    let calc_params_map: HashMap<String, Value> = serde_json::from_value(calc_params).unwrap();
    
    match client_arc.call_tool("simple_calculate", calc_params_map).await {
        Ok(result) => {
            println!("计算结果: {}", serde_json::to_string_pretty(&result).unwrap_or_else(|_| "无法格式化结果".to_string()));
        },
        Err(e) => {
            println!("调用计算工具失败: {}", e);
        }
    }
    
    println!("----------------------------------------");
    
    // 交互式对话循环
    println!("现在进入交互模式，您可以询问天气或数学计算问题:");
    loop {
        println!("\n您: ");
        let mut user_input = String::new();
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        if user_input.is_empty() {
            continue;
        }
        
        // 运行 Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析 response 为 JSON 并提取 content 字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
    }
    
    // 打印对话历史
    info!("\n对话历史:");
    match memory.load_memory_variables(&HashMap::new()).await {
        Ok(memories) => {
            if let Some(chat_history) = memories.get("chat_history") {
                if let serde_json::Value::Array(messages) = chat_history {
                    for (i, message) in messages.iter().enumerate() {
                        if let serde_json::Value::Object(msg) = message {
                            let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                            let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                            info!("{}. {}: {}", i + 1, role, content);
                        }
                    }
                }
            }
        },
        Err(e) => {
            error!("加载记忆变量失败: {}", e);
        }
    }
    
    // 断开 MCP 连接
    if let Err(e) = client_arc.disconnect().await {
        error!("断开 MCP 客户端连接失败: {}", e);
    }
    
    info!("\nMCP 客户端示例结束");
}

examples/mcp_agent_hybrid_chatbot.rs (lines 95-100)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)  // 设置日志级别为Error以便查看错误信息
        .init();
    
    info!("=== Rust Agent 混合模式示例 ===");
    
    // 从环境变量获取API密钥和基本URL
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "OPENAI_API_KEY".to_string());
    let base_url = std::env::var("OPENAI_API_URL").ok();
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://127.0.0.1:6000".to_string());  // 默认MCP服务器地址
    
    // 创建OpenAI模型实例 - 支持Openai兼容 API
    let model = OpenAIChatModel::new(api_key.clone(), base_url)
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "gpt-3.5-turbo".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化MCP客户端
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 添加本地自定义工具定义
    mcp_client.add_tools(vec![
        McpTool {
            name: "get_local_time".to_string(),
            description: "Get the current local time and date. For example: 'What time is it?'".to_string(),
        },
    ]);
    
    // 注册本地工具处理器
    mcp_client.register_tool_handler("get_local_time".to_string(), |_params: HashMap<String, Value>| async move {
        let now = chrono::Local::now();
        Ok(json!({
            "current_time": now.format("%Y-%m-%d %H:%M:%S").to_string(),
            "timezone": "Local"
        }))
    });
    
    // 不注册calculate_expression的本地处理器，让其使用服务端工具
    info!("Using local 'get_local_time' tool and server-side calculation tools...");
    
    // 尝试连接到 MCP 服务器
    match mcp_client.connect(&mcp_url).await {
        Ok(_) => {
            info!("Successfully connected to MCP server at {}", mcp_url);
            
            // 设置连接状态为已连接
            mcp_client.set_server_connected(true);
            
            // // 获取服务器工具
            // match mcp_client.get_tools().await {
            //     Ok(server_tools) => {
            //         info!("Retrieved {} tools from MCP server", server_tools.len());
            //         for tool in &server_tools {
            //             info!("Server tool: {} - {}", tool.name, tool.description);
            //         }
            //     },
            //     Err(e) => {
            //         error!("Failed to get tools from MCP server: {}", e);
            //     }
            // }
        },
        Err(e) => {
            error!("Failed to connect to MCP server: {}", e);
        }
    }

    // 创建记忆模块实例 - 使用CompositeMemory替代SimpleMemory
    let memory = CompositeMemory::with_basic_params(
        "data".into(),           // 组合记忆数据存储目录
        200,           // 摘要阈值（token数量）
        10          // 保留的最近消息数量
    ).await.expect("Failed to create CompositeMemory");

    // 创建Agent实例
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        "You are an AI assistant that can use both local tools and remote MCP server tools. Please decide whether to use tools based on the user's needs.".to_string(),
        model.clone(),
        Box::new(memory.clone())
    );
    
    // 自动从MCP客户端获取工具并添加到Agent
    // 这会同时添加MCP服务器工具和本地工具
    if let Err(e) = agent.auto_add_tools().await {
        error!("Warning: Failed to auto add tools to McpAgent: {}", e);
    }

    info!("Using model: {}", model.model_name().map_or("Model not specified", |v| v));
    info!("----------------------------------------");
    
    println!("基于MCP的混合模式AI Agent聊天机器人已启动！");
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    
    // 显示可用工具
    println!("Available tools:");
    let tools = agent.tools();
    if tools.is_empty() {
        println!("No tools available");
    } else {
        for (index, tool) in tools.iter().enumerate() {
            println!("{}. {}: {}", index + 1, tool.name(), tool.description());
        }
    }
    println!("----------------------------------------");
    
    // 示例对话
    println!("示例对话:");
    let examples = vec![
        "What time is it?",
        "What is 15.5 plus 24.3?",
    ];
    
    for example in examples {
        println!("你: {}", example);
        
        // 创建输入上下文
        let mut inputs = HashMap::new();
        inputs.insert("input".to_string(), serde_json::Value::String(example.to_string()));
        
        // 运行Agent
        match run_agent(&agent, example.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 交互式对话循环
    println!("现在开始交互式对话（输入'退出'结束对话）:");
    loop {
        let mut user_input = String::new();
        println!("你: ");
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        if user_input.is_empty() {
            continue;
        }
        
        // 运行Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 打印对话历史
    info!("对话历史:");
    match memory.load_memory_variables(&HashMap::new()).await {
        Ok(memories) => {
            if let Some(chat_history) = memories.get("chat_history") {
                if let serde_json::Value::Array(messages) = chat_history {
                    for (i, message) in messages.iter().enumerate() {
                        if let serde_json::Value::Object(msg) = message {
                            let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                            let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                            info!("{}. {}: {}", i + 1, role, content);
                        }
                    }
                }
            }
        },
        Err(e) => {
            info!("Failed to load memory variables: {}", e);
        }
    }
    
    // 断开MCP连接
    if let Err(e) = client_arc.disconnect().await {
        error!("Failed to disconnect MCP client: {}", e);
    }
}

examples/mcp_agent_local_chatbot.rs (lines 139-144)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();
    
    info!("=== Rust Agent 使用示例 ===");
    
    // 获取记忆类型配置
    let memory_type = std::env::var("MEMORY_TYPE").unwrap_or_else(|_| "composite".to_string());
    let summary_threshold = std::env::var("SUMMARY_THRESHOLD")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(200);
    let recent_messages_count = std::env::var("RECENT_MESSAGES_COUNT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(10);
    
    info!("使用记忆类型: {}", memory_type);
    info!("摘要阈值: {}", summary_threshold);
    info!("保留最近消息数: {}", recent_messages_count);
    
    // 从环境变量获取API密钥和基本URL
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "OPENAI_API_KEY".to_string());
    let base_url = std::env::var("OPENAI_API_URL").ok();
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://localhost:8000/mcp".to_string());
    
    // 创建OpenAI模型实例 - 支持Openai兼容 API
    let model = OpenAIChatModel::new(api_key.clone(), base_url)
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "gpt-3.5-turbo".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化MCP客户端
    // 在初始化 MCP 客户端后，自定义工具和工具处理器
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 添加自定义工具
    mcp_client.add_tools(vec![
        McpTool {
            name: "get_weather".to_string(),
            description: format!(
                "Get weather information for a specified city. For example: 'What's the weather like in Beijing?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"city\": \"{}\" }}'",
                "city".to_string()),
        },
        McpTool {
            name: "simple_calculate".to_string(),
            description: format!(
                "Execute simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"expression\": \"{}\" }}'",
                "expression".to_string()),
        },
    ]);
    
    // 注册自定义工具处理器
    mcp_client.register_tool_handler("get_weather".to_string(), |params: HashMap<String, Value>| async move {
        let default_city = Value::String("Shanghai".to_string());
        let city_value = params.get("city").unwrap_or(&default_city);
        let city = city_value.as_str().unwrap_or("Shanghai");
        Ok(json!({
            "city": city,
            "temperature": "25°C",
            "weather": "Sunny",
            "humidity": "40%",
            "updated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    mcp_client.register_tool_handler("simple_calculate".to_string(), |params: HashMap<String, Value>| async move {
        let expression_value = params.get("expression").ok_or_else(|| Error::msg("Missing calculation expression"))?;
        let expression = expression_value.as_str().ok_or_else(|| Error::msg("Expression format error"))?;
        
        // 解析表达式，提取操作数和运算符
        let result = parse_and_calculate(expression)?;
        
        Ok(json!({
            "expression": expression,
            "result": result,
            "calculated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    // 不连接到 MCP 服务器，仅使用本地工具
    info!("Using local tools only, not connecting to MCP server...");

    info!("Using model: {}", model.model_name().map_or("Model not specified", |v| v));
    info!("Using API URL: {}", model.base_url());
    info!("----------------------------------------");
    
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    
    // 根据配置创建不同类型的记忆模块实例
    let memory: Box<dyn BaseMemory> = match memory_type.as_str() {
        "simple" => {
            info!("使用SimpleMemory (仅内存记忆)");
            Box::new(SimpleMemory::new())
        },
        "composite" => {
            info!("使用CompositeMemory (组合记忆 - 支持中长期记忆和摘要记忆)");
            // 使用新的简化接口，只需要提供必要的参数
            // session_id将在内部自动生成
            let memory = CompositeMemory::with_basic_params(
                PathBuf::from("./data/memory"),
                summary_threshold,
                recent_messages_count,
            ).await.expect("Failed to create composite memory");
            
            Box::new(memory)
        },
        _ => {
            error!("未知的记忆类型: {}, 使用默认的SimpleMemory", memory_type);
            Box::new(SimpleMemory::new())
        }
    };

    // 创建Agent实例，并传递temperature、max_tokens和memory参数
    let user_system_prompt = "You are an AI assistant that can use tools to answer user questions. Please decide whether to use tools based on the user's needs.".to_string();
    
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        user_system_prompt,
        model.clone(),
        memory
    );
    
    // 尝试从MCP服务器自动获取工具并添加到Agent
    if let Err(e) = agent.auto_add_tools().await {
        error!("Failed to auto add tools from MCP server: {}", e);
    }
    
    println!("基于MCP的AI Agent聊天机器人已启动！");
    println!("记忆类型: {}", memory_type);
    if memory_type == "composite" {
        println!("摘要功能: 已启用 (阈值: {} 条消息)", summary_threshold);
        println!("中长期记忆: 已启用");
    }
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    println!("Using tools example:");
    let tools = client_arc.get_tools().await.unwrap_or_else(|e| {
        error!("Failed to get tools from MCP server: {}", e);
        // 返回本地工具列表
        vec![
            McpTool {
                name: "get_weather".to_string(),
                description: "Get the weather information for a specified city. For example: 'What's the weather like in Beijing?'".to_string(),
            },
            McpTool {
                name: "simple_calculate".to_string(),
                description: "Perform simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'".to_string(),
            },
        ]
    });
    
    // 打印工具列表
    let mut index = 0;
    for tool in &tools {
        index += 1;

        println!("{index}. {}: {}", tool.name, tool.description);
    }
    
    println!("----------------------------------------");
    // 对话循环
    loop {
        let mut user_input = String::new();
        println!("你: ");
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        println!("");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        // 创建输入上下文
        let mut inputs = HashMap::new();
        inputs.insert("input".to_string(), serde_json::Value::String(user_input.to_string()));
        
        // 运行Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 打印对话历史
    info!("对话历史:");
    if let Some(memory) = agent.get_memory() {
        match memory.load_memory_variables(&HashMap::new()).await {
            Ok(memories) => {
                if let Some(chat_history) = memories.get("chat_history") {
                    if let serde_json::Value::Array(messages) = chat_history {
                        info!("总消息数: {}", messages.len());
                        for (i, message) in messages.iter().enumerate() {
                            if let serde_json::Value::Object(msg) = message {
                                let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                                let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                                // 限制内容长度以便显示
                                let display_content = if content.len() > 100 {
                                    format!("{}...", &content[..100])
                                } else {
                                    content.to_string()
                                };
                                info!("{}. {}: {}", i + 1, role, display_content);
                            }
                        }
                    }
                }
                
                // 如果有摘要，也打印出来
                if let Some(summary) = memories.get("summary") {
                    if let serde_json::Value::String(summary_text) = summary {
                        info!("对话摘要: {}", summary_text);
                    }
                }
            },
            Err(e) => {
                info!("Failed to load memory variables: {}", e);
            }
        }
    } else {
        info!("No memory available");
    }
    
    // 断开MCP连接
    if let Err(e) = client_arc.disconnect().await {
        error!("Failed to disconnect MCP client: {}", e);
    }
}

pub fn get_memory(&self) -> Option<&Box<dyn BaseMemory>>

Get a reference to the memory module

Examples found in repository

examples/mcp_agent_local_chatbot.rs (line 225)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();
    
    info!("=== Rust Agent 使用示例 ===");
    
    // 获取记忆类型配置
    let memory_type = std::env::var("MEMORY_TYPE").unwrap_or_else(|_| "composite".to_string());
    let summary_threshold = std::env::var("SUMMARY_THRESHOLD")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(200);
    let recent_messages_count = std::env::var("RECENT_MESSAGES_COUNT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(10);
    
    info!("使用记忆类型: {}", memory_type);
    info!("摘要阈值: {}", summary_threshold);
    info!("保留最近消息数: {}", recent_messages_count);
    
    // 从环境变量获取API密钥和基本URL
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "OPENAI_API_KEY".to_string());
    let base_url = std::env::var("OPENAI_API_URL").ok();
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://localhost:8000/mcp".to_string());
    
    // 创建OpenAI模型实例 - 支持Openai兼容 API
    let model = OpenAIChatModel::new(api_key.clone(), base_url)
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "gpt-3.5-turbo".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化MCP客户端
    // 在初始化 MCP 客户端后，自定义工具和工具处理器
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 添加自定义工具
    mcp_client.add_tools(vec![
        McpTool {
            name: "get_weather".to_string(),
            description: format!(
                "Get weather information for a specified city. For example: 'What's the weather like in Beijing?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"city\": \"{}\" }}'",
                "city".to_string()),
        },
        McpTool {
            name: "simple_calculate".to_string(),
            description: format!(
                "Execute simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"expression\": \"{}\" }}'",
                "expression".to_string()),
        },
    ]);
    
    // 注册自定义工具处理器
    mcp_client.register_tool_handler("get_weather".to_string(), |params: HashMap<String, Value>| async move {
        let default_city = Value::String("Shanghai".to_string());
        let city_value = params.get("city").unwrap_or(&default_city);
        let city = city_value.as_str().unwrap_or("Shanghai");
        Ok(json!({
            "city": city,
            "temperature": "25°C",
            "weather": "Sunny",
            "humidity": "40%",
            "updated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    mcp_client.register_tool_handler("simple_calculate".to_string(), |params: HashMap<String, Value>| async move {
        let expression_value = params.get("expression").ok_or_else(|| Error::msg("Missing calculation expression"))?;
        let expression = expression_value.as_str().ok_or_else(|| Error::msg("Expression format error"))?;
        
        // 解析表达式，提取操作数和运算符
        let result = parse_and_calculate(expression)?;
        
        Ok(json!({
            "expression": expression,
            "result": result,
            "calculated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    // 不连接到 MCP 服务器，仅使用本地工具
    info!("Using local tools only, not connecting to MCP server...");

    info!("Using model: {}", model.model_name().map_or("Model not specified", |v| v));
    info!("Using API URL: {}", model.base_url());
    info!("----------------------------------------");
    
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    
    // 根据配置创建不同类型的记忆模块实例
    let memory: Box<dyn BaseMemory> = match memory_type.as_str() {
        "simple" => {
            info!("使用SimpleMemory (仅内存记忆)");
            Box::new(SimpleMemory::new())
        },
        "composite" => {
            info!("使用CompositeMemory (组合记忆 - 支持中长期记忆和摘要记忆)");
            // 使用新的简化接口，只需要提供必要的参数
            // session_id将在内部自动生成
            let memory = CompositeMemory::with_basic_params(
                PathBuf::from("./data/memory"),
                summary_threshold,
                recent_messages_count,
            ).await.expect("Failed to create composite memory");
            
            Box::new(memory)
        },
        _ => {
            error!("未知的记忆类型: {}, 使用默认的SimpleMemory", memory_type);
            Box::new(SimpleMemory::new())
        }
    };

    // 创建Agent实例，并传递temperature、max_tokens和memory参数
    let user_system_prompt = "You are an AI assistant that can use tools to answer user questions. Please decide whether to use tools based on the user's needs.".to_string();
    
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        user_system_prompt,
        model.clone(),
        memory
    );
    
    // 尝试从MCP服务器自动获取工具并添加到Agent
    if let Err(e) = agent.auto_add_tools().await {
        error!("Failed to auto add tools from MCP server: {}", e);
    }
    
    println!("基于MCP的AI Agent聊天机器人已启动！");
    println!("记忆类型: {}", memory_type);
    if memory_type == "composite" {
        println!("摘要功能: 已启用 (阈值: {} 条消息)", summary_threshold);
        println!("中长期记忆: 已启用");
    }
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    println!("Using tools example:");
    let tools = client_arc.get_tools().await.unwrap_or_else(|e| {
        error!("Failed to get tools from MCP server: {}", e);
        // 返回本地工具列表
        vec![
            McpTool {
                name: "get_weather".to_string(),
                description: "Get the weather information for a specified city. For example: 'What's the weather like in Beijing?'".to_string(),
            },
            McpTool {
                name: "simple_calculate".to_string(),
                description: "Perform simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'".to_string(),
            },
        ]
    });
    
    // 打印工具列表
    let mut index = 0;
    for tool in &tools {
        index += 1;

        println!("{index}. {}: {}", tool.name, tool.description);
    }
    
    println!("----------------------------------------");
    // 对话循环
    loop {
        let mut user_input = String::new();
        println!("你: ");
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        println!("");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        // 创建输入上下文
        let mut inputs = HashMap::new();
        inputs.insert("input".to_string(), serde_json::Value::String(user_input.to_string()));
        
        // 运行Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 打印对话历史
    info!("对话历史:");
    if let Some(memory) = agent.get_memory() {
        match memory.load_memory_variables(&HashMap::new()).await {
            Ok(memories) => {
                if let Some(chat_history) = memories.get("chat_history") {
                    if let serde_json::Value::Array(messages) = chat_history {
                        info!("总消息数: {}", messages.len());
                        for (i, message) in messages.iter().enumerate() {
                            if let serde_json::Value::Object(msg) = message {
                                let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                                let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                                // 限制内容长度以便显示
                                let display_content = if content.len() > 100 {
                                    format!("{}...", &content[..100])
                                } else {
                                    content.to_string()
                                };
                                info!("{}. {}: {}", i + 1, role, display_content);
                            }
                        }
                    }
                }
                
                // 如果有摘要，也打印出来
                if let Some(summary) = memories.get("summary") {
                    if let serde_json::Value::String(summary_text) = summary {
                        info!("对话摘要: {}", summary_text);
                    }
                }
            },
            Err(e) => {
                info!("Failed to load memory variables: {}", e);
            }
        }
    } else {
        info!("No memory available");
    }
    
    // 断开MCP连接
    if let Err(e) = client_arc.disconnect().await {
        error!("Failed to disconnect MCP client: {}", e);
    }
}

pub fn add_tool(&mut self, tool: Box<dyn Tool + Send + Sync>)

Add a tool to the Agent

pub async fn auto_add_tools(&mut self) -> Result<(), Error>

Automatically get tools from MCP client and add them to the Agent This method gets all available tools from the MCP client and wraps them as McpToolAdapter before adding to the Agent Local tool registration and addition are handled by the caller

Examples found in repository

examples/mcp_agent_client_chatbot.rs (line 75)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();
    
    info!("=== Rust Agent MCP 客户端调用服务端工具示例 ===");
    
    // 从环境变量获取 MCP 服务器 URL
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://127.0.0.1:6000".to_string());
    
    // 创建 OpenAI 模型实例（可选，用于智能决策是否调用工具）
    // 如果没有设置 API 密钥，则使用一个占位符
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "sk-00000".to_string());
    let base_url = std::env::var("OPENAI_API_URL").unwrap_or("https://api.deepseek.com/v1".to_string());
    let model = OpenAIChatModel::new(api_key.clone(), Some(base_url))
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "deepseek-chat".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化 MCP 客户端
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 不添加任何本地工具，完全依赖服务端工具
    info!("Not adding any local tools, will use server-side tools only...");
    
    // 注意：客户端不需要实现工具处理器，因为工具实际在服务端执行
    // 客户端只需要知道工具的名称和描述即可
    
    // 连接到 MCP 服务器
    info!("正在连接到 MCP 服务器: {}", mcp_url);
    if let Err(e) = mcp_client.connect(&mcp_url).await {
        error!("连接到 MCP 服务器失败: {}", e);
        return;
    } else {
        mcp_client.set_server_connected(true);
    }
    info!("成功连接到 MCP 服务器");
    
    // let model_name = model.model_name().map_or("未指定模型".to_string(), |v| v.to_string());
    
    info!("----------------------------------------");
    
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    
    // 创建记忆模块实例
    let memory = SimpleMemory::new();

    // 创建 Agent 实例
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        "You are an AI assistant that can use tools to answer user questions. Please decide whether to use tools based on the user's needs.".to_string(),
        model.clone(),
        Box::new(memory.clone())
    );
    
    // 自动从 MCP 客户端获取工具并添加到 Agent
    if let Err(e) = agent.auto_add_tools().await {
        error!("自动添加工具到 Agent 失败: {}", e);
        return;
    }
    
    println!("MCP 客户端 Agent 已启动！");
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    
    // 获取并显示可用工具
    let tools = client_arc.get_tools().await.unwrap_or_else(|e| {
        error!("获取工具列表失败: {}", e);
        vec![]
    });
    
    println!("可用工具:");
    for (index, tool) in tools.iter().enumerate() {
        println!("{}. {}: {}", index + 1, tool.name, tool.description);
    }
    
    println!("----------------------------------------");
    
    // 演示直接调用工具
    println!("演示直接调用工具:");
    
    // 调用天气工具
    println!("\n1. 调用天气工具获取北京天气: What's the weather like in Beijing?");
    let mut weather_params = HashMap::new();
    weather_params.insert("city".to_string(), Value::String("Beijing".to_string()));
    
    match client_arc.call_tool("get_weather", weather_params).await {
        Ok(result) => {
            println!("天气查询结果: {}", serde_json::to_string_pretty(&result).unwrap_or_else(|_| "无法格式化结果".to_string()));
        },
        Err(e) => {
            println!("调用天气工具失败: {}", e);
        }
    }
    
    // 调用计算工具
    println!("\n2. 调用计算工具计算: 'What is 15.5 plus 24.3?'");
    let calc_params = json!({
        "expression": "15.5 + 24.3"
    });
    let calc_params_map: HashMap<String, Value> = serde_json::from_value(calc_params).unwrap();
    
    match client_arc.call_tool("simple_calculate", calc_params_map).await {
        Ok(result) => {
            println!("计算结果: {}", serde_json::to_string_pretty(&result).unwrap_or_else(|_| "无法格式化结果".to_string()));
        },
        Err(e) => {
            println!("调用计算工具失败: {}", e);
        }
    }
    
    println!("----------------------------------------");
    
    // 交互式对话循环
    println!("现在进入交互模式，您可以询问天气或数学计算问题:");
    loop {
        println!("\n您: ");
        let mut user_input = String::new();
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        if user_input.is_empty() {
            continue;
        }
        
        // 运行 Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析 response 为 JSON 并提取 content 字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
    }
    
    // 打印对话历史
    info!("\n对话历史:");
    match memory.load_memory_variables(&HashMap::new()).await {
        Ok(memories) => {
            if let Some(chat_history) = memories.get("chat_history") {
                if let serde_json::Value::Array(messages) = chat_history {
                    for (i, message) in messages.iter().enumerate() {
                        if let serde_json::Value::Object(msg) = message {
                            let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                            let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                            info!("{}. {}: {}", i + 1, role, content);
                        }
                    }
                }
            }
        },
        Err(e) => {
            error!("加载记忆变量失败: {}", e);
        }
    }
    
    // 断开 MCP 连接
    if let Err(e) = client_arc.disconnect().await {
        error!("断开 MCP 客户端连接失败: {}", e);
    }
    
    info!("\nMCP 客户端示例结束");
}

examples/mcp_agent_hybrid_chatbot.rs (line 104)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)  // 设置日志级别为Error以便查看错误信息
        .init();
    
    info!("=== Rust Agent 混合模式示例 ===");
    
    // 从环境变量获取API密钥和基本URL
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "OPENAI_API_KEY".to_string());
    let base_url = std::env::var("OPENAI_API_URL").ok();
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://127.0.0.1:6000".to_string());  // 默认MCP服务器地址
    
    // 创建OpenAI模型实例 - 支持Openai兼容 API
    let model = OpenAIChatModel::new(api_key.clone(), base_url)
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "gpt-3.5-turbo".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化MCP客户端
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 添加本地自定义工具定义
    mcp_client.add_tools(vec![
        McpTool {
            name: "get_local_time".to_string(),
            description: "Get the current local time and date. For example: 'What time is it?'".to_string(),
        },
    ]);
    
    // 注册本地工具处理器
    mcp_client.register_tool_handler("get_local_time".to_string(), |_params: HashMap<String, Value>| async move {
        let now = chrono::Local::now();
        Ok(json!({
            "current_time": now.format("%Y-%m-%d %H:%M:%S").to_string(),
            "timezone": "Local"
        }))
    });
    
    // 不注册calculate_expression的本地处理器，让其使用服务端工具
    info!("Using local 'get_local_time' tool and server-side calculation tools...");
    
    // 尝试连接到 MCP 服务器
    match mcp_client.connect(&mcp_url).await {
        Ok(_) => {
            info!("Successfully connected to MCP server at {}", mcp_url);
            
            // 设置连接状态为已连接
            mcp_client.set_server_connected(true);
            
            // // 获取服务器工具
            // match mcp_client.get_tools().await {
            //     Ok(server_tools) => {
            //         info!("Retrieved {} tools from MCP server", server_tools.len());
            //         for tool in &server_tools {
            //             info!("Server tool: {} - {}", tool.name, tool.description);
            //         }
            //     },
            //     Err(e) => {
            //         error!("Failed to get tools from MCP server: {}", e);
            //     }
            // }
        },
        Err(e) => {
            error!("Failed to connect to MCP server: {}", e);
        }
    }

    // 创建记忆模块实例 - 使用CompositeMemory替代SimpleMemory
    let memory = CompositeMemory::with_basic_params(
        "data".into(),           // 组合记忆数据存储目录
        200,           // 摘要阈值（token数量）
        10          // 保留的最近消息数量
    ).await.expect("Failed to create CompositeMemory");

    // 创建Agent实例
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        "You are an AI assistant that can use both local tools and remote MCP server tools. Please decide whether to use tools based on the user's needs.".to_string(),
        model.clone(),
        Box::new(memory.clone())
    );
    
    // 自动从MCP客户端获取工具并添加到Agent
    // 这会同时添加MCP服务器工具和本地工具
    if let Err(e) = agent.auto_add_tools().await {
        error!("Warning: Failed to auto add tools to McpAgent: {}", e);
    }

    info!("Using model: {}", model.model_name().map_or("Model not specified", |v| v));
    info!("----------------------------------------");
    
    println!("基于MCP的混合模式AI Agent聊天机器人已启动！");
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    
    // 显示可用工具
    println!("Available tools:");
    let tools = agent.tools();
    if tools.is_empty() {
        println!("No tools available");
    } else {
        for (index, tool) in tools.iter().enumerate() {
            println!("{}. {}: {}", index + 1, tool.name(), tool.description());
        }
    }
    println!("----------------------------------------");
    
    // 示例对话
    println!("示例对话:");
    let examples = vec![
        "What time is it?",
        "What is 15.5 plus 24.3?",
    ];
    
    for example in examples {
        println!("你: {}", example);
        
        // 创建输入上下文
        let mut inputs = HashMap::new();
        inputs.insert("input".to_string(), serde_json::Value::String(example.to_string()));
        
        // 运行Agent
        match run_agent(&agent, example.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 交互式对话循环
    println!("现在开始交互式对话（输入'退出'结束对话）:");
    loop {
        let mut user_input = String::new();
        println!("你: ");
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        if user_input.is_empty() {
            continue;
        }
        
        // 运行Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 打印对话历史
    info!("对话历史:");
    match memory.load_memory_variables(&HashMap::new()).await {
        Ok(memories) => {
            if let Some(chat_history) = memories.get("chat_history") {
                if let serde_json::Value::Array(messages) = chat_history {
                    for (i, message) in messages.iter().enumerate() {
                        if let serde_json::Value::Object(msg) = message {
                            let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                            let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                            info!("{}. {}: {}", i + 1, role, content);
                        }
                    }
                }
            }
        },
        Err(e) => {
            info!("Failed to load memory variables: {}", e);
        }
    }
    
    // 断开MCP连接
    if let Err(e) = client_arc.disconnect().await {
        error!("Failed to disconnect MCP client: {}", e);
    }
}

examples/mcp_agent_local_chatbot.rs (line 147)

async fn main() {
    // 初始化日志记录器
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();
    
    info!("=== Rust Agent 使用示例 ===");
    
    // 获取记忆类型配置
    let memory_type = std::env::var("MEMORY_TYPE").unwrap_or_else(|_| "composite".to_string());
    let summary_threshold = std::env::var("SUMMARY_THRESHOLD")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(200);
    let recent_messages_count = std::env::var("RECENT_MESSAGES_COUNT")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(10);
    
    info!("使用记忆类型: {}", memory_type);
    info!("摘要阈值: {}", summary_threshold);
    info!("保留最近消息数: {}", recent_messages_count);
    
    // 从环境变量获取API密钥和基本URL
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| "OPENAI_API_KEY".to_string());
    let base_url = std::env::var("OPENAI_API_URL").ok();
    let mcp_url = std::env::var("MCP_URL").unwrap_or("http://localhost:8000/mcp".to_string());
    
    // 创建OpenAI模型实例 - 支持Openai兼容 API
    let model = OpenAIChatModel::new(api_key.clone(), base_url)
        .with_model(std::env::var("OPENAI_API_MODEL").unwrap_or_else(|_| "gpt-3.5-turbo".to_string()))
        .with_temperature(0.7)
        .with_max_tokens(8*1024);
    
    // 初始化MCP客户端
    // 在初始化 MCP 客户端后，自定义工具和工具处理器
    let mut mcp_client = SimpleMcpClient::new(mcp_url.clone());
    
    // 清空默认工具（可选）
    mcp_client.clear_tools();
    
    // 添加自定义工具
    mcp_client.add_tools(vec![
        McpTool {
            name: "get_weather".to_string(),
            description: format!(
                "Get weather information for a specified city. For example: 'What's the weather like in Beijing?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"city\": \"{}\" }}'",
                "city".to_string()),
        },
        McpTool {
            name: "simple_calculate".to_string(),
            description: format!(
                "Execute simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'.
                The parameter request body you should extract is: '\"parameters\": {{ \"expression\": \"{}\" }}'",
                "expression".to_string()),
        },
    ]);
    
    // 注册自定义工具处理器
    mcp_client.register_tool_handler("get_weather".to_string(), |params: HashMap<String, Value>| async move {
        let default_city = Value::String("Shanghai".to_string());
        let city_value = params.get("city").unwrap_or(&default_city);
        let city = city_value.as_str().unwrap_or("Shanghai");
        Ok(json!({
            "city": city,
            "temperature": "25°C",
            "weather": "Sunny",
            "humidity": "40%",
            "updated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    mcp_client.register_tool_handler("simple_calculate".to_string(), |params: HashMap<String, Value>| async move {
        let expression_value = params.get("expression").ok_or_else(|| Error::msg("Missing calculation expression"))?;
        let expression = expression_value.as_str().ok_or_else(|| Error::msg("Expression format error"))?;
        
        // 解析表达式，提取操作数和运算符
        let result = parse_and_calculate(expression)?;
        
        Ok(json!({
            "expression": expression,
            "result": result,
            "calculated_at": chrono::Utc::now().to_rfc3339()
        }))
    });
    
    // 不连接到 MCP 服务器，仅使用本地工具
    info!("Using local tools only, not connecting to MCP server...");

    info!("Using model: {}", model.model_name().map_or("Model not specified", |v| v));
    info!("Using API URL: {}", model.base_url());
    info!("----------------------------------------");
    
    let client_arc: Arc<dyn McpClient> = Arc::new(mcp_client);
    
    // 根据配置创建不同类型的记忆模块实例
    let memory: Box<dyn BaseMemory> = match memory_type.as_str() {
        "simple" => {
            info!("使用SimpleMemory (仅内存记忆)");
            Box::new(SimpleMemory::new())
        },
        "composite" => {
            info!("使用CompositeMemory (组合记忆 - 支持中长期记忆和摘要记忆)");
            // 使用新的简化接口，只需要提供必要的参数
            // session_id将在内部自动生成
            let memory = CompositeMemory::with_basic_params(
                PathBuf::from("./data/memory"),
                summary_threshold,
                recent_messages_count,
            ).await.expect("Failed to create composite memory");
            
            Box::new(memory)
        },
        _ => {
            error!("未知的记忆类型: {}, 使用默认的SimpleMemory", memory_type);
            Box::new(SimpleMemory::new())
        }
    };

    // 创建Agent实例，并传递temperature、max_tokens和memory参数
    let user_system_prompt = "You are an AI assistant that can use tools to answer user questions. Please decide whether to use tools based on the user's needs.".to_string();
    
    let mut agent = McpAgent::with_openai_model_and_memory(
        client_arc.clone(),
        user_system_prompt,
        model.clone(),
        memory
    );
    
    // 尝试从MCP服务器自动获取工具并添加到Agent
    if let Err(e) = agent.auto_add_tools().await {
        error!("Failed to auto add tools from MCP server: {}", e);
    }
    
    println!("基于MCP的AI Agent聊天机器人已启动！");
    println!("记忆类型: {}", memory_type);
    if memory_type == "composite" {
        println!("摘要功能: 已启用 (阈值: {} 条消息)", summary_threshold);
        println!("中长期记忆: 已启用");
    }
    println!("输入'退出'结束对话");
    println!("----------------------------------------");
    println!("Using tools example:");
    let tools = client_arc.get_tools().await.unwrap_or_else(|e| {
        error!("Failed to get tools from MCP server: {}", e);
        // 返回本地工具列表
        vec![
            McpTool {
                name: "get_weather".to_string(),
                description: "Get the weather information for a specified city. For example: 'What's the weather like in Beijing?'".to_string(),
            },
            McpTool {
                name: "simple_calculate".to_string(),
                description: "Perform simple mathematical calculations. For example: 'What is 9.11 plus 9.8?'".to_string(),
            },
        ]
    });
    
    // 打印工具列表
    let mut index = 0;
    for tool in &tools {
        index += 1;

        println!("{index}. {}: {}", tool.name, tool.description);
    }
    
    println!("----------------------------------------");
    // 对话循环
    loop {
        let mut user_input = String::new();
        println!("你: ");
        std::io::stdin().read_line(&mut user_input).expect("读取输入失败");
        println!("");
        let user_input = user_input.trim();
        
        if user_input.to_lowercase() == "退出" || user_input.to_lowercase() == "exit" {
            println!("再见！");
            break;
        }
        
        // 创建输入上下文
        let mut inputs = HashMap::new();
        inputs.insert("input".to_string(), serde_json::Value::String(user_input.to_string()));
        
        // 运行Agent
        match run_agent(&agent, user_input.to_string()).await {
            Ok(response) => {
                // 尝试解析response为JSON并提取content字段
                if let Ok(json_value) = serde_json::from_str::<serde_json::Value>(&response) {
                    if let Some(content) = json_value.get("content").and_then(|v| v.as_str()) {
                        println!("助手: {}", content);
                    } else {
                        println!("助手: {}", response);
                    }
                } else {
                    println!("助手: {}", response);
                }
            },
            Err(e) => {
                println!("助手: 抱歉，处理您的请求时出现错误: {}", e);
            },
        }
        
        info!("----------------------------------------");
    }
    
    // 打印对话历史
    info!("对话历史:");
    if let Some(memory) = agent.get_memory() {
        match memory.load_memory_variables(&HashMap::new()).await {
            Ok(memories) => {
                if let Some(chat_history) = memories.get("chat_history") {
                    if let serde_json::Value::Array(messages) = chat_history {
                        info!("总消息数: {}", messages.len());
                        for (i, message) in messages.iter().enumerate() {
                            if let serde_json::Value::Object(msg) = message {
                                let role = msg.get("role").and_then(|v| v.as_str()).unwrap_or("unknown");
                                let content = msg.get("content").and_then(|v| v.as_str()).unwrap_or("");
                                // 限制内容长度以便显示
                                let display_content = if content.len() > 100 {
                                    format!("{}...", &content[..100])
                                } else {
                                    content.to_string()
                                };
                                info!("{}. {}: {}", i + 1, role, display_content);
                            }
                        }
                    }
                }
                
                // 如果有摘要，也打印出来
                if let Some(summary) = memories.get("summary") {
                    if let serde_json::Value::String(summary_text) = summary {
                        info!("对话摘要: {}", summary_text);
                    }
                }
            },
            Err(e) => {
                info!("Failed to load memory variables: {}", e);
            }
        }
    } else {
        info!("No memory available");
    }
    
    // 断开MCP连接
    if let Err(e) = client_arc.disconnect().await {
        error!("Failed to disconnect MCP client: {}", e);
    }
}

Trait Implementations

impl Agent for McpAgent

fn tools(&self) -> Vec<Box<dyn Tool + Send + Sync>>

fn execute( &self, _action: &AgentAction, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + '_>>

fn clone_agent(&self) -> Box<dyn Agent>

impl Clone for McpAgent

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Runnable<HashMap<String, String>, AgentOutput> for McpAgent

fn invoke( &self, input: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<AgentOutput, Error>> + Send>>

fn clone_to_owned( &self, ) -> Box<dyn Runnable<HashMap<String, String>, AgentOutput> + Send + Sync>

fn invoke_with_config( &self, input: I, _config: Option<HashMap<String, Value>>, ) -> Pin<Box<dyn Future<Output = Result<O, Error>> + Send>>

fn batch( &self, inputs: Vec<I>, ) -> Pin<Box<dyn Future<Output = Vec<Result<O, Error>>> + Send>>

fn batch_with_config( &self, inputs: Vec<I>, _config: Option<HashMap<String, Value>>, ) -> Pin<Box<dyn Future<Output = Vec<Result<O, Error>>> + Send>>

fn stream(&self, input: I) -> Box<dyn Stream<Item = Result<O, Error>> + Send>

fn astream( &self, _input: I, ) -> Pin<Box<dyn Future<Output = Box<dyn Stream<Item = Result<O, Error>> + Send>> + Send>>