Struct OpenAIChatModel 

pub struct OpenAIChatModel { /* private fields */ }

Implementations

impl OpenAIChatModel

pub fn new(api_key: String, base_url: Option<String>) -> Self

Create a new OpenAI chat model instance

Examples found in repository

examples/mcp_agent_client_chatbot.rs (line 30)

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 29)

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 45)

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 model_name(&self) -> Option<&String>

Get model name

Examples found in repository

examples/mcp_agent_hybrid_chatbot.rs (line 108)

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 106)

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 base_url(&self) -> &String

Get base URL

Examples found in repository

examples/mcp_agent_local_chatbot.rs (line 107)

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 temperature(&self) -> Option<f32>

Get temperature parameter

pub fn max_tokens(&self) -> Option<u32>

Get maximum number of tokens

pub fn with_model(self, model_name: String) -> Self

Set model name

Examples found in repository

examples/mcp_agent_client_chatbot.rs (line 31)

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 30)

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 46)

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 with_temperature(self, temperature: f32) -> Self

Set temperature parameter

Examples found in repository

examples/mcp_agent_client_chatbot.rs (line 32)

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 31)

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 47)

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 with_max_tokens(self, max_tokens: u32) -> Self

Set maximum number of tokens

Examples found in repository

examples/mcp_agent_client_chatbot.rs (line 33)

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 32)

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 48)

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 with_api_type(self, api_type: OpenAIApiType) -> Self

Set API type (Chat Completions or Responses)

pub fn with_additional_header(self, key: String, value: String) -> Self

Add additional request headers

pub fn with_additional_param(self, key: String, value: Value) -> Self

Add additional request parameters

Trait Implementations

impl ChatModel for OpenAIChatModel

fn model_name(&self) -> Option<&str>

fn base_url(&self) -> String

fn invoke( &self, messages: Vec<ChatMessage>, ) -> Pin<Box<dyn Future<Output = Result<ChatCompletion, Error>> + Send + '_>>

impl Clone for OpenAIChatModel

fn clone(&self) -> OpenAIChatModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.