使用说明

优化MCP

Claude Code的高级优化工具-9个用于生产的专用求解器

版本：2.5.0（所有4个增强功能均已完成）状态：生产准备就绪（9个工具+1个编排技能）

快速启动（60秒）

想马上试试吗？以下是最快的路径：

1.安装依赖项（10秒）

git clone https://github.com/your-org/optimization-mcp
cd optimization-mcp
pip install -r requirements.txt

2.测试它是否有效（10秒）

# test_basic.py
from src.api.allocation import optimize_allocation

result = optimize_allocation(
    objective={
        "sense": "maximize",
        "items": [
            {"name": "project_a", "value": 100},
            {"name": "project_b", "value": 150}
        ]
    },
    resources={"budget": {"total": 10000}},
    item_requirements=[
        {"name": "project_a", "budget": 6000},
        {"name": "project_b", "budget": 5000}
    ]
)

print(f"Status: {result['status']}")
print(f"Optimal value: {result['objective_value']}")
print(f"Allocation: {result['allocation']}")

运行： python test_basic.py

预期输出:

Status: optimal
Optimal value: 250.0
Allocation: {'project_a': 1, 'project_b': 1}

3.在克劳德代码中使用（30秒）

添加到 ~/.claude.json:

{
  "mcpServers": {
    "optimization-mcp": {
      "command": "python",
      "args": ["/path/to/optimization-mcp/server.py"]
    }
  }
}

重新启动Claude Code，然后尝试：

Claude, use optimization-mcp to allocate a $100K budget across 3 marketing channels

4.下一步（10秒）

阅读全部文件在......下面
尝试示例工作流
探索全部9个工具

概述

优化MCP提供基于约束的优化功能，可与现有的蒙特卡洛MCP无缝集成。找到最佳的资源分配，跨场景的稳健解决方案，并在不确定性下做出数据驱动的决策。

主要特点

深度MC集成：每个工具都有自己的蒙特卡洛意识——使用百分位值、预期结果或完整的场景分布
生产解决方案：PuLP（LP/MILP）、SciPy（非线性）、CVXPY（二次型）、NetworkX（网络流）
高性能：NetworkX为物流/路线问题提供10-100x的加速（1K-10K变量）
零摩擦工作流程：优化输出直接输入蒙特卡洛验证工具
开源：不需要商业许可证（不需要Gurobi/CPLEX）
生产就绪：内部测试，全面的错误处理，有用的诊断
全面覆盖：网络流、帕累托边界、随机规划、列生成

帕累托前沿可视化

多目标优化平衡冲突目标（利润与可持续性）：

此可视化演示了帕累托前沿工具如何探索竞争目标之间的权衡，帮助您在多个最优解决方案中做出战略决策。

安装

通过插件市场（推荐）

# Add marketplace
claude plugin marketplace add eesb99/optimization-mcp

# Install plugin
claude plugin install optimization-mcp

# Verify installation
/mcp
# Should show: ✔ optimization-mcp (connected, 9 tools)

手动安装

# Clone repository
git clone https://github.com/eesb99/optimization-mcp.git ~/.claude/mcp-servers/optimization-mcp

# Run setup
cd ~/.claude/mcp-servers/optimization-mcp
./setup.sh

# Add to ~/.claude.json
{
  "mcpServers": {
    "optimization-mcp": {
      "command": "/Users/[username]/.claude/mcp-servers/optimization-mcp/run.sh"
    }
  }
}

# Restart Claude Code

自动设置：The setup.sh 脚本会自动创建一个虚拟环境并安装所有依赖项。

重要免责声明

软件保修

本软件根据MIT许可证“按原样”提供，不提供任何明示或暗示的保证。作者对使用本软件造成的任何损害不承担责任。在实施之前，始终验证优化结果。

商业决策通知

优化结果是基于输入数据和假设的数学模型。虽然算法经过严格测试，但现实世界的决策需要：

与领域专家一起验证结果
关键参数敏感性分析
部署前使用历史数据进行测试
了解模型限制和假设

财务建议免责声明

投资组合优化工具仅用于教育和分析目的。它不构成财务、投资或专业建议。在做出投资决策之前，咨询合格的财务顾问。过去的性能和模型输出不能保证未来的结果。

准确性和验证

所有优化工具都经过全面的内部测试和验证，但用户应该：

独立验证关键应用程序的结果
生产使用前对已知问题进行测试
验证假设和输入数据质量
仔细查看求解器状态和警告
考虑多种情景和敏感性分析

推荐：从非关键应用程序开始，彻底验证，然后扩展到生产使用。

工具

1. `optimize_allocation`

目的：资源分配受到限制（预算、时间、能力）

用例:

跨渠道营销预算
各产品的生产能力
资源有限的项目选择
饮料/食品的成分配方

示例:

result = optimize_allocation(
    objective={
        "items": [
            {"name": "google_ads", "value": 125000},  # Expected ROI
            {"name": "linkedin", "value": 87000}
        ],
        "sense": "maximize"
    },
    resources={
        "budget": {"total": 100000}
    },
    item_requirements=[
        {"name": "google_ads", "budget": 25000},
        {"name": "linkedin", "budget": 18000}
    ]
)

# Output:
# {
#   "status": "optimal",
#   "objective_value": 212000.0,
#   "allocation": {"google_ads": 1, "linkedin": 1, ...},
#   "resource_usage": {...},
#   "shadow_prices": {"budget": 1.25},  # Worth $1.25 per extra $1
#   "monte_carlo_compatible": {...}      # Ready for MC validation
# }

蒙特卡罗积分:

# Use P50 (median) values from Monte Carlo simulation
result = optimize_allocation(
    objective={...},
    resources={...},
    item_requirements=[...],
    monte_carlo_integration={
        "mode": "percentile",
        "percentile": "p50",
        "mc_output": mc_simulation_result
    }
)

参数:

objective：骰子 items （列表）和 sense （“最大化”/“最小化”）
resources：资源限制（例如。， {"budget": {"total": 100000}})
item_requirements：每个项目所需资源的字典列表
constraints：可选的附加约束
monte_carlo_integration：可选MC集成（3种模式：百分位数、预期、场景）
solver_options：可选(time_limit, verbose)

退货:

status：“最优”、“不可行”、“无界”或“错误”
objective_value：最佳值
allocation：所选项目的骰子（1=已选，0=未选）
resource_usage：每种资源的利用率统计数据
shadow_prices：放宽每个约束的边际值
monte_carlo_compatible：输出格式化以进行MC验证

多目标优化

v1.1.0中的新功能：通过加权标量化优化多个竞争目标。

用例:

平衡利润和可持续性
权衡回报与风险
同时优化成本和质量
任何多准则决策问题

示例:

result = optimize_allocation(
    objective={
        "sense": "maximize",
        "functions": [
            {
                "name": "profit",
                "items": [
                    {"name": "product_a", "value": 100},
                    {"name": "product_b", "value": 150}
                ],
                "weight": 0.7  # 70% weight on profit
            },
            {
                "name": "sustainability",
                "items": [
                    {"name": "product_a", "value": 80},
                    {"name": "product_b", "value": 60}
                ],
                "weight": 0.3  # 30% weight on sustainability
            }
        ]
    },
    resources={
        "budget": {"total": 50000}
    },
    item_requirements=[
        {"name": "product_a", "budget": 25000},
        {"name": "product_b", "budget": 30000}
    ]
)

# Output includes objective breakdown:
# {
#   "status": "optimal",
#   "objective_value": 127.0,  # 0.7*140 + 0.3*70
#   "allocation": {"product_a": 1, "product_b": 0},
#   "objective_breakdown": {
#       "profit": {
#           "value": 100,
#           "weight": 0.7,
#           "weighted_value": 70.0
#       },
#       "sustainability": {
#           "value": 80,
#           "weight": 0.3,
#           "weighted_value": 24.0
#       }
#   }
# }

需求:

至少需要2个目标函数
权重总和必须为1.0（在0.01公差范围内）
每个权重必须介于0和1之间
每个函数都有自己的 items 列表与 name 和 value

向后兼容：单目标格式仍然和以前一样。

增强约束

v2.0.0中的新功能：用于复杂决策逻辑的高级约束类型。

约束类型:

1.有条件的（If Then）:

constraints=[
    {
        "type": "conditional",
        "condition_item": "project_a",
        "then_item": "project_b",
        "description": "if_a_then_b"
    }
]
# If project_a is selected, then project_b MUST be selected

2.非连接（OR-至少N）:

constraints=[
    {
        "type": "disjunctive",
        "items": ["option_a", "option_b", "option_c"],
        "min_selected": 2,
        "description": "pick_at_least_2"
    }
]
# At least 2 of the 3 options must be selected

3.相互排他性（确切地说是N）:

constraints=[
    {
        "type": "mutex",
        "items": ["strategy_a", "strategy_b", "strategy_c"],
        "exactly": 1,
        "description": "pick_exactly_one"
    }
]
# Exactly 1 strategy must be selected (XOR logic)

组合示例:

# Complex business logic: Pick one core product + conditionally required addons
result = optimize_allocation(
    objective={...},
    resources={...},
    item_requirements=[...],
    constraints=[
        {"type": "mutex", "items": ["core_a", "core_b"], "exactly": 1},
        {"type": "conditional", "condition_item": "core_a", "then_item": "addon_1"},
        {"type": "disjunctive", "items": ["addon_1", "addon_2"], "min_selected": 1}
    ]
)

用例:

产品捆绑规则
技术依赖链
战略选择
监管合规约束

2. `optimize_robust`

目的：找到在蒙特卡洛场景中运行良好的稳健解决方案

用例:

在85%以上的场景中有效的分配
最坏情况优化
风险约束决策

示例:

# Step 1: Run Monte Carlo to generate scenarios
mc_result = run_business_scenario(
    scenario_name="Product Launch",
    revenue_assumptions={...},
    cost_structure={...},
    num_simulations=10000
)

# Step 2: Find robust allocation
result = optimize_robust(
    objective={
        "items": [{"name": "project_a"}, {"name": "project_b"}],
        "sense": "maximize"
    },
    resources={"budget": {"total": 100000}},
    item_requirements=[...],
    monte_carlo_scenarios={
        "scenarios": mc_result["scenarios"]  # All 10K scenarios
    },
    robustness_criterion="best_average",
    risk_tolerance=0.85  # Works in 85% of scenarios
)

# Output:
# {
#   "allocation": {...},
#   "robustness_metrics": {
#     "expected_outcome": 125000,
#     "worst_case_outcome": 95000,
#     "scenarios_meeting_threshold": 0.92,  # 92% of scenarios succeed
#     "outcome_percentiles": {"p10": 98000, "p50": 125000, "p90": 152000}
#   },
#   "outcome_distribution": [...]  # Outcome in each scenario
# }

参数:

objective, resources, item_requirements：与optimize_allocation相同
monte_carlo_scenarios：骰子 scenarios MC输出列表
robustness_criterion：“最佳平均值”、“最差情况”或“百分位数”
risk_tolerance：浮点数（0-1），例如0.85=在85%的情况下有效
constraints, solver_options：可选

退货:

allocation：稳健的分配决策
robustness_metrics：跨场景的性能统计
outcome_distribution：验证结果列表
monte_carlo_compatible：MC工具的输出

3. `optimize_portfolio`

v2.0.0中的新功能：使用二次规划进行风险回报权衡的投资组合优化。

目的：考虑相关性和风险，优化投资组合配置

用例:

投资组合配置
风险回报权衡的资产选择
夏普比率最大化
高效的边境建设

优化目标:

夏普比率：最大化（回报-无风险）/风险
最小方差：将投资组合风险降至最低，实现目标回报
最大回报：最大化目标风险的回报

示例1：夏普比率优化:

result = optimize_portfolio(
    assets=[
        {"name": "US_equity", "expected_return": 0.10},
        {"name": "intl_equity", "expected_return": 0.09},
        {"name": "bonds", "expected_return": 0.04}
    ],
    covariance_matrix=[
        [0.0225, 0.0100, 0.0020],  # US equity: 15% std, correlations
        [0.0100, 0.0256, 0.0015],  # Intl equity: 16% std
        [0.0020, 0.0015, 0.0036]   # Bonds: 6% std
    ],
    optimization_objective="sharpe",
    risk_free_rate=0.025,
    constraints={
        "max_weight": 0.70,  # Max 70% in any asset
        "min_weight": 0.10   # Min 10% in each
    }
)

# Output:
# {
#   "status": "optimal",
#   "weights": {"US_equity": 0.70, "intl_equity": 0.20, "bonds": 0.10},
#   "expected_return": 0.092,  # 9.2% expected return
#   "portfolio_std": 0.1234,   # 12.34% risk (std dev)
#   "sharpe_ratio": 0.543,     # (9.2% - 2.5%) / 12.34%
#   "assets": [
#       {
#           "name": "US_equity",
#           "weight": 0.70,
#           "risk_contribution_pct": 165.1  # Contributes 165% of risk (due to correlations)
#       },
#       ...
#   ]
# }

示例2：最小方差:

# Find lowest-risk portfolio that achieves 6% return
result = optimize_portfolio(
    assets=[...],
    covariance_matrix=[...],
    constraints={"target_return": 0.06},
    optimization_objective="min_variance"
)
# Returns portfolio with minimum variance achieving 6% return

示例3：最大回报:

# Find highest-return portfolio within risk budget
result = optimize_portfolio(
    assets=[...],
    covariance_matrix=[...],
    constraints={"target_risk": 0.03},  # Max variance = 3%
    optimization_objective="max_return"
)
# Returns portfolio with maximum return within risk limit

参数:

assets：列表 {"name": str, "expected_return": float}
covariance_matrix：资产回报协方差的N×N矩阵
optimization_objective: "sharpe", "min_variance"，或 "max_return"
risk_free_rate：夏普的无风险利率（默认值：0.02）
constraints：可选：
- max_weight：每项资产的最大权重（例如，0.30=30%）
- min_weight：每项资产的最小权重（例如，0.05=5%）
- target_return：必需 min_variance 目标
- target_risk：必需 max_return 目标
- long_only：防止卖空（默认值：True）
monte_carlo_integration：可选MC集成
solver_options：可选求解器设置

退货:

status：优化状态
weights：最佳投资组合权重的骰子（总和为1.0）
expected_return：投资组合预期回报
portfolio_variance：投资组合差异（风险²）
portfolio_std：投资组合标准差（风险）
sharpe_ratio：（返回-rf）/std
assets：资产层面的详细信息，包括风险贡献
monte_carlo_compatible：MC验证输出

求解器：带SCS的CVXPY（处理二次目标和约束）

4. `optimize_schedule`

v2.0.0中的新功能：具有依赖关系和资源约束的任务调度。

目的：考虑任务依赖性、资源限制和时间限制，优化项目进度

用例:

项目进度安排（RCPSP）
车间作业调度
任务优先级与截止日期
随时间推移的资源分配

优化目标:

最小化Makespan：尽快完成项目
最大化价值：在时间预算内优先处理高价值任务

示例1：软件项目进度表:

result = optimize_schedule(
    tasks=[
        {"name": "design", "duration": 5, "value": 100, "dependencies": [], "resources": {"developers": 2}},
        {"name": "backend", "duration": 10, "value": 200, "dependencies": ["design"], "resources": {"developers": 3}},
        {"name": "frontend", "duration": 8, "value": 150, "dependencies": ["design"], "resources": {"developers": 2}},
        {"name": "testing", "duration": 4, "value": 80, "dependencies": ["backend", "frontend"], "resources": {"developers": 2}}
    ],
    resources={"developers": {"total": 5}},
    time_horizon=30,
    optimization_objective="minimize_makespan"
)

# Output:
# {
#   "status": "optimal",
#   "makespan": 19,  # Project finishes at time 19
#   "schedule": {"design": 0, "backend": 5, "frontend": 5, "testing": 15},
#   "critical_path": ["design", "backend", "testing"],  # Tasks determining makespan
#   "resource_usage": {...},  # Developer utilization over time
#   "tasks": [
#       {"name": "design", "start_time": 0, "end_time": 5, "on_critical_path": true},
#       ...
#   ]
# }

示例2：有截止日期:

result = optimize_schedule(
    tasks=[...],
    resources={...},
    time_horizon=30,
    constraints=[
        {"type": "deadline", "task": "testing", "time": 20},  # Must finish by time 20
        {"type": "parallel_limit", "limit": 3}  # Max 3 tasks in parallel
    ]
)

参数:

tasks：任务列表，包括：
- name：任务标识符
- duration：所需时间单位
- value：任务值/优先级（可选，用于最大值）
- dependencies：必备任务名称列表（可选）
- resources：每个时间单位的资源需求（可选）
resources：每个时间段的可用资源
time_horizon：总调度窗口
constraints：可选的时间约束：
- 截止日期：任务必须在时间T前完成
- 发布：任务不能在时间T之前开始
- 并行限制：最多可同时执行N个任务
optimization_objective: "minimize_makespan" 或 "maximize_value"
monte_carlo_integration：不确定持续时间的可选MC
solver_options：可选求解器设置

退货:

status：优化状态
schedule：骰子映射任务→ 开始时间
makespan：项目完成时间（尽量减少工作量）
total_value：计划任务值的总和（最大值）
resource_usage：资源利用时间表
critical_path：任务顺序决定完成时间
tasks：带有关键路径标记的任务级详细信息
monte_carlo_compatible：MC验证输出

求解器：带CBC的PuLP（任务时间分配的MILP）

5. `optimize_execute`

v2.1.0中的新功能：具有自动求解器选择和灵活问题规范的自定义优化。

目的：用于快速原型制作和定制优化问题的高级用户工具

用例:

自定义优化配方不符合标准模板
新优化问题的快速原型制作
当你知道数学形式并想要自动选择求解器时
教育/研究应用

主要特点:

自动求解器选择：自动检测并选择最佳求解器（PuLP/SciPy/CVXPY）
灵活的规格：基于骰子的问题定义
所有求解器均可访问：可以覆盖自动检测以强制特定求解器

示例1：简单背包问题:

result = optimize_execute(
    problem_definition={
        "variables": [
            {"name": "item1", "type": "binary"},
            {"name": "item2", "type": "binary"},
            {"name": "item3", "type": "binary"}
        ],
        "objective": {
            "coefficients": {"item1": 60, "item2": 100, "item3": 120},
            "sense": "maximize"
        },
        "constraints": [
            # Weight: 10*item1 + 20*item2 + 30*item3 <= 50
            {"coefficients": {"item1": 10, "item2": 20, "item3": 30}, "type": "<=", "rhs": 50}
        ]
    },
    auto_detect=True
)

# Output:
# {
#   "status": "optimal",
#   "solver_used": "pulp",  # Auto-detected for binary variables
#   "objective_value": 220.0,
#   "solution": {"item1": 0, "item2": 1, "item3": 1},
#   "solve_time_seconds": 0.032,
#   "problem_info": {"num_variables": 3, "num_constraints": 1}
# }

示例2：使用解算器覆盖:

# Force CVXPY for continuous linear problem
result = optimize_execute(
    problem_definition={
        "variables": [
            {"name": "x", "type": "continuous", "bounds": (0, 10)},
            {"name": "y", "type": "continuous", "bounds": (0, 10)}
        ],
        "objective": {
            "coefficients": {"x": 3, "y": 4},
            "sense": "maximize"
        },
        "constraints": [
            {"coefficients": {"x": 1, "y": 2}, "type": "<=", "rhs": 10}
        ]
    },
    auto_detect=False,
    solver_preference="cvxpy"  # Override auto-detection
)

参数:

problem_definition：骰子：
- variables：列表 {"name": str, "type": "continuous"|"integer"|"binary", "bounds": (lower, upper)}
- objective: {"coefficients": {var: coeff}, "sense": "maximize"|"minimize"}
- constraints：列表 {"coefficients": {var: coeff}, "type": "<="|">="|"==", "rhs": number}
auto_detect：自动选择最佳解算器（默认值：True）
solver_preference：用覆盖 "pulp", "scipy"，或 "cvxpy"
monte_carlo_integration：可选MC集成
solver_options：可选(time_limit, verbose)

退货:

status：优化状态
solver_used：选择了哪个求解器
objective_value：最佳值
solution：变量值骰子
solve_time_seconds：求解时间
problem_info：问题统计
shadow_prices 或 dual_values：灵敏度信息（取决于求解器）
monte_carlo_compatible：MC验证输出

自动检测逻辑:

具有二进制/整数变量→ PuLP（加拿大广播公司）
连续线性→ PuLP（默认）
可以用以下方式覆盖 solver_preference 参数

何时使用:

✅ 您遇到自定义问题，无法安装标准模板
✅ 您希望使用dict规范快速制作原型
✅ 您需要从一个界面访问所有3个求解器
✅ 你对数学公式很熟悉

何时不使用:

❌ 标准分配→ 改用optimize_allocation
❌ 投资组合→ 改用optimize_portfolio
❌ 调度→ 改用optimize_schedule

求解器：自动选择（PuLP/SciPy/CVXPY）或手动超控

为什么optimize_excute是你的“逃生舱”

灵活性层：虽然专用工具覆盖了90%的用例， optimize_execute 是专门为另外10%设计的。

当专用工具合适时 （先使用这些）：

预算分配→ optimize_allocation
投资组合→ optimize_portfolio
调度→ optimize_schedule
网络路由→ optimize_network_flow
多目标权衡→ optimize_pareto

当您需要定制配方时 （使用optimize_excute）：

定制背包变体
异常约束类型
新问题的快速原型制作
教育/研究应用
是否存在不符合标准模板的问题

把它当作:

专用工具 =高级API（简单、固执己见，90%的病例）
优化执行 =低级API（灵活、一般、10%的病例）

示例-自定义多维背包:

# Specialized tools don't support this exact variant
# Use optimize_execute for full flexibility
result = optimize_execute(
    problem_definition={
        "variables": [
            {"name": f"item_{i}", "type": "binary"}
            for i in range(100)
        ],
        "objective": {
            "coefficients": {f"item_{i}": values[i] for i in range(100)},
            "sense": "maximize"
        },
        "constraints": [
            # Weight constraint
            {"coefficients": {f"item_{i}": weights[i] for i in range(100)},
             "type": "<=", "rhs": capacity},
            # Volume constraint
            {"coefficients": {f"item_{i}": volumes[i] for i in range(100)},
             "type": "<=", "rhs": max_volume},
            # Custom: At most 10 items from category A
            {"coefficients": {f"item_{i}": 1 for i in category_a_items},
             "type": "<=", "rhs": 10}
        ]
    },
    auto_detect=True
)

有:

求解器的自动检测（PuLP用于此二元问题）
数学规划的全部力量
没有专门工具的样板
蒙特卡洛积分仍然可用

两者都有自己的位置 -在合适的时候使用专门的工具（更容易、更好的验证）， optimize_execute 当你需要完全控制的时候。

6. `optimize_network_flow`

v2.2.0中的新功能：使用专门的NetworkX算法进行网络流优化，速度提高10-100x。

目的：解决网络流量问题（最小成本流量、最大流量、分配）

用例:

供应链路线（仓库→ 客户分布）
运输物流（最大限度地降低运输成本）
分配问题（工人到任务，机器到工作）
最大吞吐量/容量问题

主要特点:

高性能：NetworkX专用算法比普通LP快10-100倍
自动求解器选择：NetworkX用于纯网络流，PuLP回退用于复杂约束
瓶颈分析：标识容量受限的边
节点余额跟踪：每个节点的流量守恒验证

示例1：供应链最小成本流:

result = optimize_network_flow(
    network={
        "nodes": [
            {"id": "warehouse_A", "supply": 100},
            {"id": "customer_1", "demand": 40},
            {"id": "customer_2", "demand": 60}
        ],
        "edges": [
            {"from": "warehouse_A", "to": "customer_1", "capacity": 50, "cost": 5.0},
            {"from": "warehouse_A", "to": "customer_2", "capacity": 80, "cost": 3.0}
        ]
    },
    flow_type="min_cost"
)

# Output:
# {
#   "status": "optimal",
#   "solver": "networkx",
#   "total_cost": 380.0,  # 40*5 + 60*3
#   "flow_solution": {
#       "flow_warehouse_A_customer_1": 40,
#       "flow_warehouse_A_customer_2": 60
#   },
#   "bottlenecks": [{"edge": "...", "utilization": 1.0}],
#   "node_balance": {...},
#   "solve_time_seconds": 0.0001,  # 1000x faster than LP!
#   "monte_carlo_compatible": {...}
# }

示例2：最大流量:

result = optimize_network_flow(
    network={
        "nodes": [
            {"id": "source", "supply": 1000},
            {"id": "intermediate", "demand": 0},
            {"id": "sink", "demand": 1000}
        ],
        "edges": [
            {"from": "source", "to": "intermediate", "capacity": 50},
            {"from": "intermediate", "to": "sink", "capacity": 100}
        ]
    },
    flow_type="max_flow"
)
# Finds maximum throughput (50 units, limited by first bottleneck)

示例3：作业问题:

result = optimize_network_flow(
    network={
        "nodes": [
            {"id": "worker_1", "supply": 1},
            {"id": "worker_2", "supply": 1},
            {"id": "task_A", "demand": 1},
            {"id": "task_B", "demand": 1}
        ],
        "edges": [
            {"from": "worker_1", "to": "task_A", "cost": 10},
            {"from": "worker_1", "to": "task_B", "cost": 15},
            {"from": "worker_2", "to": "task_A", "cost": 12},
            {"from": "worker_2", "to": "task_B", "cost": 8}
        ]
    },
    flow_type="assignment"
)
# Finds optimal one-to-one matching (worker_1→task_A, worker_2→task_B, cost=18)

何时使用:

✅ 纯网络流问题（路由、物流、分配）
✅ 速度重要的大规模问题（1K-10K变量）
✅ 考虑运输成本的供应链优化
✅ 容量/吞吐量最大化

何时不使用:

❌ 多种商品流（不同产品类型）→ 使用优化分配
❌ 流量守恒之外的复杂侧面约束→ 使用PuLP优化execute

求解器：NetworkX（主要），具有PuLP回退功能，适用于复杂情况演出：100个节点小于0.001秒，1000个节点小于2秒

7. `optimize_pareto`

v2.3.0中的新功能：帕累托多目标优化——探索全面权衡前沿。

目的：生成完整的帕累托边界，显示冲突目标之间的所有权衡

用例:

战略规划（利润vs可持续性vs风险）
设计优化（成本vs质量vs时间）
产品选择（收入与客户满意度）
多标准决策支持

主要特点:

全前沿一代：20-100个非支配解决方案（不仅仅是一个加权点）
膝盖点建议：自动识别最佳平衡解决方案
权衡分析：量化目标之间的边际替代率
混合感官：同时处理最大化和最小化目标

示例：利润与可持续性权衡:

result = optimize_pareto(
    objectives=[
        {
            "name": "profit",
            "items": [
                {"name": "project_a", "value": 125000},
                {"name": "project_b", "value": 87000}
            ],
            "sense": "maximize"
        },
        {
            "name": "sustainability",
            "items": [
                {"name": "project_a", "value": 65},
                {"name": "project_b", "value": 92}
            ],
            "sense": "maximize"
        }
    ],
    resources={"budget": {"total": 100000}},
    item_requirements=[
        {"name": "project_a", "budget": 60000},
        {"name": "project_b", "budget": 45000}
    ],
    num_points=20  # Generate 20 frontier points
)

# Output:
# {
#   "status": "optimal",
#   "pareto_frontier": [
#       {
#           "weights": {"profit": 1.0, "sustainability": 0.0},
#           "allocation": {"project_a": 1, "project_b": 0},
#           "objective_values": {"profit": 125000, "sustainability": 65}
#       },
#       ... 18 more points ...
#       {
#           "weights": {"profit": 0.0, "sustainability": 1.0},
#           "allocation": {"project_a": 0, "project_b": 1},
#           "objective_values": {"profit": 87000, "sustainability": 92}
#       }
#   ],
#   "num_frontier_points": 20,
#   "recommended_point": {...},  # Knee point (best balance)
#   "tradeoff_analysis": {
#       "objective_ranges": {...},
#       "tradeoff_rates": {"sustainability_per_profit": {...}}
#   }
# }

何时使用:

✅ 不知道“正确”的权衡权重
✅ 需要向高管/利益相关者展示多种选择
✅ 想要了解对目标优先级的敏感性
✅ 多准则决策问题

何时不使用:

❌ 已经知道确切的重量→ 使用多目标优化分配
❌ 单一目标→ 使用优化分配

求解器：PuLP（系统地求解加权和）演出：20个边境点约0.5-2s

可扩展性指南

了解每个工具的性能特征有助于您选择正确的方法并设定现实的期望。

优化分配

建议限值:

项目：<500（最佳性能）
资源：<100
二进制/整数变量：<1000
限制：<1000

性能特征:

使用PuLP和CBC求解器（分支和切割MIP）
小问题（<50项）：<1秒
中等问题（50-500个项目）：<10秒
大问题（500-1000项）：<60秒

何时使用：预算分配、资源分配、选择问题

optimize_robust

建议限值:

项目：<100（候选生成是组合的）
场景：<1000
总评价（项目×情景）：<100000

性能特征:

生成候选分配，跨场景评估
评估时间随场景呈线性增长
候选项的生成可以是指数级的

何时使用：不确定性下的风险意识分配

优化投资组合

建议限值:

资产：<500
协方差矩阵：N×N必须适合内存（~500×500=2MB）

性能特征:

将CVXPY与SCS/OSQP求解器结合使用（二次规划）
小型投资组合（<50个资产）：<1秒
中等投资组合（50-200项资产）：<5秒
大型投资组合（200-500项资产）：<30秒

何时使用：投资组合优化，风险回报权衡

优化时间表

建议限值:

任务：<50
时间范围：<100个周期
总时间索引变量（任务×时间范围）：<5000

性能特征:

使用时间索引公式（每个任务时间对的二进制变量）
变量=任务×时间_地平线
小项目（<20个任务）：<10秒
中等项目（20-50个任务）：<60秒

何时使用：项目进度安排、资源有限的规划

优化网络流

建议限值:

节点数：<10000
边缘：<100000

性能特征:

使用NetworkX专用算法（网络单纯形，Edmonds-Karp）
利用网络结构，与普通LP相比，速度提高了100-5000倍
小型网络（<100个节点）：<0.1秒
中型网络（100-1000个节点）：<1秒
大型网络（1000-10000个节点）：<10秒

何时使用：运输、物流、路线、分配问题

优化路径

建议限值:

前沿点：20-100（更多点=更精细的权衡曲线）
项目：与优化分配相同
目标：2-4（可视化难度超过3）

性能特征:

每个边界点解决一个优化问题
总时间≈单次优化×点数
20分通常需要10-30秒

何时使用：多目标权衡分析，探索决策空间

优化_随机

建议限值:

场景：<200（大尺寸线性缩放）
第一阶段变量：<500
第二阶段变量：<500
问题总大小：n₁ + S×n₂ < 100,000

性能特征:

使用2级扩展形式（单个大型LP）
问题大小=第一阶段+场景×第二阶段
50个场景，100个变量/阶段：约5秒
200个场景，200个变量/阶段：约60秒

何时使用：具有不确定性的连续决策（库存、产能规划）

优化_列_根

建议限值:

主问题变量：<10000（框架就绪，用户实现定价）
迭代次数：<100

性能特征:

大规模问题（>1000个变量）的框架
性能取决于用户提供的定价子问题
当前返回带有初始列（占位符定价）

何时使用：非常大的问题，削减库存，人员安排（需要定制定价）

优化执行

建议限值:

变量：取决于自动检测的求解器
- PuLP（LP/MIP）：<10000个变量
- SciPy（非线性）：<1000个变量
- CVXPY（QP）：<5000个变量

性能特征:

自动检测问题类型并选择合适的求解器
性能与所选后端求解器匹配

何时使用：专用工具未涵盖的自定义问题

性能提示

从小事做起：首先使用全问题大小的10-20%进行测试
使用network_flow解决网络问题：比普通LP快100-5000倍
减少场景：50个场景通常足以解决随机问题
在简单情况下使用稳健而非随机：更快的评估，没有广泛的形式
帕累托前沿：20分通常足以看到权衡曲线
检查求解器选项：设置 time_limit 防止失控解决

当您达到比例限制时

如果您的问题超出建议的限制：

分解：分解成更小的子问题
聚合：将类似项目/资源分组
采样：使用随机情景子集
启发法：将optimize_robust与候选采样一起使用
列生成：对于非常大的问题，使用optimize_column_gen
商业解决方案：考虑使用Gurobi/CPLEX进行10倍以上的加速（不包括在内）

蒙特卡罗积分模式

该MCP具有深厚的蒙特卡洛积分-每个工具都可以在不确定性下工作。然而，工具根据其需求使用不同的模式。

模式摘要

工具	MC参数	支持的模式	用途
optimize_allocation	monte_carlo-integration	预期百分比	在目标中使用MC值
optimize_robust	monte_carlo场景	仅场景	跨所有场景进行评估
optimize_portfolio	monte_carlo-integration	预期百分比	使用MC回报/协方差
optimize_schedule	monte_carlo-integration	预期百分比	使用MC持续时间
optimize_excute	monte_carlo-integration	预期百分比	使用MC系数
optimize_network_flow	monte_carlo-integration	预期百分比	使用MC成本/容量
optimize_pareto	monte_carlo-integration	预期百分位数	使用MC目标值
optimize_stocastic	场景	仅场景	显式建模不确定性

模式类型A：百分比/预期（大多数工具）

使用：分配、投资组合、进度、执行、网络流、帕累托

目的：从MC输出中提取特定值（P10/P50/P90或预期值）并用于优化

示例:

# Step 1: Generate MC scenarios
mc_result = run_business_scenario(
    scenario_name="Revenue Forecast",
    assumptions={...},
    num_simulations=10000
)

# Step 2: Use P50 (median) values in optimization
result = optimize_allocation(
    objective={...},
    resources={...},
    item_requirements=[...],
    monte_carlo_integration={
        "mode": "percentile",      # or "expected"
        "percentile": "p50",        # p10, p50, or p90
        "mc_output": mc_result      # Full MC output
    }
)

模式:

"percentile"：使用分布中的P10/P50/P90值
- P10=保守（悲观）
- P50=基本情况（中位数）
- P90=乐观
"expected"：使用分布的平均值

发生了什么：工具从中提取指定的百分位数/预期值 mc_output 并将其用于优化

模式类型B：情景（稳健和随机）

使用：optimize_robust，optimize_stochastic

目的：评估所有情景下的决策（而不仅仅是百分之一）

optimize_robust示例:

# Step 1: Generate MC scenarios
mc_result = run_business_scenario(
    scenario_name="Product Launch",
    assumptions={...},
    num_simulations=10000
)

# Step 2: Find robust allocation
result = optimize_robust(
    objective={...},
    resources={...},
    item_requirements=[...],
    monte_carlo_scenarios={
        "scenarios": mc_result["scenarios"]  # Pass ALL scenarios
    },
    robustness_criterion="best_average",
    risk_tolerance=0.85  # Works in 85% of scenarios
)

optimize_stochastic示例:

result = optimize_stochastic(
    first_stage={...},
    second_stage={...},
    scenarios=[  # Explicit scenario list
        {"probability": 0.2, "demand": 100, "price": 50},
        {"probability": 0.5, "demand": 150, "price": 45},
        {"probability": 0.3, "demand": 200, "price": 40}
    ]
)

发生了什么：工具评估所有场景的优化

optimize_robust：根据所有场景测试候选分配
optimize_stochastic：在两阶段公式中明确建模不确定性

何时使用哪种模式

在以下情况下使用模式A（百分位数/预期值）:

你想要一个单一的确定性优化
您可以放心地选择P10/P50/P90作为前置
你想要快速解决问题
示例：“使用投资回报率中值分配预算”

在以下情况下使用模式B（场景）:

你希望在不确定性中保持稳健性
你关心最坏的情况或风险承受能力
你需要有不确定性启示的连续决策
示例：“找到在85%的情况下有效的分配”

常见工作流

工作流程1：保守规划

# Use P10 (pessimistic) for conservative allocation
result = optimize_allocation(
    ...,
    monte_carlo_integration={
        "mode": "percentile",
        "percentile": "p10",
        "mc_output": mc_result
    }
)

工作流程2：稳健优化

# First try base case (P50)
base = optimize_allocation(..., percentile="p50")

# Then test robustness across all scenarios
robust = optimize_robust(
    ...,
    monte_carlo_scenarios={"scenarios": mc_result["scenarios"]}
)

# Compare: Does base case work in 85%+ scenarios?

工作流程3：随机顺序决策

# Inventory planning: Order now, adjust later based on demand
result = optimize_stochastic(
    first_stage={  # Order decision (now)
        "variables": [...],
        "objective": {...}
    },
    second_stage={  # Adjustment decision (after seeing demand)
        "variables": [...],
        "objective": {...}
    },
    scenarios=[...]  # Possible demand scenarios
)

迁移指南

如果您正在使用旧模式并希望更新：

旧（仍然有效）:

optimize_allocation(objective={...}, resources={...}, item_requirements=[...])

新（带MC）:

optimize_allocation(
    objective={...},
    resources={...},
    item_requirements=[...],
    monte_carlo_integration={
        "mode": "percentile",
        "percentile": "p50",
        "mc_output": mc_result
    }
)

向后兼容：所有工具在没有MC参数的情况下工作（确定性模式）

图式语法参考

跨多个工具使用的通用数据结构。学习一次，随处使用。

资源定义

用于：优化分配、优化调度、优化重置、优化随机、优化鲁棒

格式:

{
  "resource_name": {
    "total": number,        # Required: Total available amount
    "unit": string          # Optional: Unit of measurement
  }
}

例子:

# Simple budget
resources = {"budget": {"total": 100000}}

# Multiple resources with units
resources = {
    "budget": {"total": 100000, "unit": "USD"},
    "time": {"total": 40, "unit": "hours"},
    "capacity": {"total": 500, "unit": "units"}
}

项目要求

用于：optimize_allocation、optimize_robust、optimized_pareto

格式:

[
  {
    "name": string,          # Required: Unique item identifier
    "resource1": number,     # Required: Amount of resource1 needed
    "resource2": number,     # Optional: Amount of resource2 needed
    ...
  }
]

例子:

# Budget-only requirements
item_requirements = [
    {"name": "campaign_a", "budget": 25000},
    {"name": "campaign_b", "budget": 18000}
]

# Multi-resource requirements
item_requirements = [
    {
        "name": "project_a",
        "budget": 60000,
        "time": 20,
        "capacity": 100
    },
    {
        "name": "project_b",
        "budget": 45000,
        "time": 15,
        "capacity": 75
    }
]

重要：需求中的资源名称必须与 resources 字典

目标规范

用于：optimize_allocation、optimize_robust、optimized_pareto

单目标格式:

{
  "sense": "maximize" | "minimize",
  "items": [
    {
      "name": string,      # Must match name in item_requirements
      "value": number      # Objective coefficient
    }
  ]
}

多目标格式 （仅限分配）：

{
  "sense": "maximize" | "minimize",
  "functions": [
    {
      "name": string,      # Function name (e.g., "profit")
      "weight": number,    # Weight (0-1, must sum to 1.0)
      "items": [
        {"name": string, "value": number}
      ]
    }
  ]
}

示例:

# Single objective
objective = {
    "sense": "maximize",
    "items": [
        {"name": "product_a", "value": 100},
        {"name": "product_b", "value": 150}
    ]
}

# Multi-objective (profit vs sustainability)
objective = {
    "sense": "maximize",
    "functions": [
        {
            "name": "profit",
            "weight": 0.7,
            "items": [
                {"name": "product_a", "value": 100},
                {"name": "product_b", "value": 150}
            ]
        },
        {
            "name": "sustainability",
            "weight": 0.3,
            "items": [
                {"name": "product_a", "value": 80},
                {"name": "product_b", "value": 60}
            ]
        }
    ]
}

约束规范

用于：优化分配，优化时间表

格式:

[
  {
    "type": "min" | "max" | "conditional" | "disjunctive" | "mutex",
    "items": [string],           # Item names
    "limit": number,             # For min/max
    "min_selected": number,      # For disjunctive
    "exactly": number,           # For mutex
    "condition_item": string,    # For conditional
    "then_item": string,         # For conditional
    "description": string        # Optional: Human-readable
  }
]

例子:

# Minimum selection (at least 1 core product)
{"type": "min", "items": ["core_a", "core_b"], "limit": 1}

# If-then logic (if A then must have B)
{"type": "conditional", "condition_item": "project_a", "then_item": "project_b"}

# Pick at least N (at least 2 of 3 options)
{"type": "disjunctive", "items": ["opt1", "opt2", "opt3"], "min_selected": 2}

# Pick exactly N (exactly 1 strategy - XOR)
{"type": "mutex", "items": ["strategy_a", "strategy_b"], "exactly": 1}

# Combined (complex business logic)
constraints = [
    {"type": "mutex", "items": ["core_a", "core_b"], "exactly": 1},
    {"type": "conditional", "condition_item": "core_a", "then_item": "addon_1"},
    {"type": "disjunctive", "items": ["addon_1", "addon_2"], "min_selected": 1}
]

网络规范

用于：优化网络流

格式:

{
  "nodes": [
    {
      "id": string,            # Unique node identifier
      "supply": number,        # Positive = source (optional)
      "demand": number         # Positive = sink (optional)
    }
  ],
  "edges": [
    {
      "from": string,          # Source node id
      "to": string,            # Target node id
      "capacity": number,      # Max flow on edge (optional)
      "cost": number           # Cost per unit flow (optional)
    }
  ]
}

示例:

network = {
    "nodes": [
        {"id": "warehouse", "supply": 100},
        {"id": "customer_1", "demand": 40},
        {"id": "customer_2", "demand": 60}
    ],
    "edges": [
        {"from": "warehouse", "to": "customer_1", "capacity": 50, "cost": 5.0},
        {"from": "warehouse", "to": "customer_2", "capacity": 80, "cost": 3.0}
    ]
}

节点类型:

来源： supply > 0 （产生流量）
水槽： demand > 0 （消耗流量）
转运：既没有供应也没有需求（传递流量）

求解器选项

用于：所有工具

格式:

{
  "time_limit": number,        # Optional: Max solve time (seconds)
  "verbose": boolean           # Optional: Enable debug output
}

示例:

solver_options = {
    "time_limit": 30,   # Stop after 30 seconds
    "verbose": True      # Print solver progress
}

用法:

result = optimize_allocation(
    objective={...},
    resources={...},
    item_requirements=[...],
    solver_options={"time_limit": 60, "verbose": False}
)

规范工作流程

工作流程1：优化→ 验证→ 稳健性检验

找到最优分配，用蒙特卡洛验证，测试假设的稳健性。

User: "Allocate $100K marketing budget with uncertain ROI"

Step 1: Optimize allocation
result = optimize_allocation(
    objective={...},
    resources={"budget": {"total": 100000}},
    item_requirements=[...]
)

Step 2: Validate confidence (uses MC-compatible output)
confidence = validate_reasoning_confidence(
    decision_context="Q1 marketing allocation",
    assumptions=result["monte_carlo_compatible"]["assumptions"],
    success_criteria=result["monte_carlo_compatible"]["recommended_params"]["success_criteria"]
)
# Returns: 87% chance of achieving >90% of optimal value

Step 3: Test robustness
robustness = test_assumption_robustness(
    base_answer=f"Allocate {result['allocation']}",
    critical_assumptions=result["monte_carlo_compatible"]["assumptions"],
    stress_test_ranges={...}
)
# Returns: Breaks if Google Ads ROI < $35K (currently $50K)

Result: Optimal allocation + 87% confidence + breaking points identified

工作流程2:MC场景→ 稳健优化

使用蒙特卡洛生成场景，优化鲁棒性。

User: "Find allocation that works in 85% of scenarios"

Step 1: Generate MC scenarios
mc = run_business_scenario(
    scenario_name="Product Launch",
    revenue_assumptions={...},
    num_simulations=10000
)

Step 2: Robust optimization
opt = optimize_robust(
    objective={...},
    monte_carlo_scenarios={"scenarios": mc["scenarios"]},
    risk_tolerance=0.85
)

Step 3: Sensitivity analysis
sensitivity = run_sensitivity_analysis(
    variables_to_test=["revenue", "cost"],
    outcome_data=opt["outcome_distribution"]
)

Result: Robust allocation + sensitivity tornado diagram

技术架构

解算器

求解器	类型	最适合	规模
PuLP+CBC	LP/MILP	资源分配、调度、制定	最多10000个变量
SciPy	非线性	带边界/约束的连续优化	10-1000个变量

文件结构

optimization-mcp/
├── server.py                    # MCP entry point
├── src/
│   ├── api/                     # Tool implementations
│   │   ├── allocation.py        # optimize_allocation
│   │   └── robust.py            # optimize_robust
│   ├── solvers/                 # Solver wrappers
│   │   ├── base_solver.py       # Abstract base class
│   │   ├── pulp_solver.py       # PuLP wrapper
│   │   └── scipy_solver.py      # SciPy wrapper
│   ├── integration/             # MC integration
│   │   ├── monte_carlo.py       # MC integration layer
│   │   └── data_converters.py   # Data validation
│   └── utils/                   # Utilities

绩效目标

问题大小	目标时间	用例
小（<50个变量）	<1秒	公式问题
中等（50-500个变量）	<10秒	资源分配
大型（500-1000个变量）	<60秒	复杂的调度

故障排除

MCP未加载

检查配置：

grep -A5 '"optimization-mcp"' ~/.claude/config/mcp-profiles.json

验证server.py是否可执行：

ls -l ~/.claude/mcp-servers/optimization-mcp/server.py

检查日志：
```
tail -f /tmp/optimization-mcp.log
```

无法解决的问题

如果你得到 status: "infeasible":

检查是否至少有一个项目符合资源限制
验证约束是否相互矛盾
使用较小的问题进行调试

缓慢解决

如果优化时间超过60秒：

减少问题规模（减少项目/约束）
添加 solver_options: {"time_limit": 30} 早点停下来
考虑分解为子问题

路线图

第2周（下一步）

工具3： optimize_portfolio -利用夏普比率优化投资组合
工具4： optimize_schedule -具有依赖关系的任务调度
二次目标的CVXPY积分

第3周

工具5： optimize_execute -具有代码执行功能的自定义工作流
编排技巧： robust-optimization -端到端自动化
性能基准和优化

例子

示例1：营销预算分配

Problem: Allocate $100K across 5 channels with uncertain conversion rates

# Generate MC scenarios for conversion uncertainty
mc_result = run_business_scenario(
    scenario_name="Marketing ROI",
    revenue_assumptions={
        "seo_conversion": {"distribution": "normal", "params": {"mean": 0.04, "std": 0.01}},
        "content_conversion": {"distribution": "normal", "params": {"mean": 0.03, "std": 0.008}},
        # ... other channels
    },
    num_simulations=10000
)

# Optimize using P50 (median) values
opt_result = optimize_allocation(
    objective={
        "items": [
            {"name": "seo", "value": "from_mc"},
            {"name": "content", "value": "from_mc"},
            # ... other channels
        ],
        "sense": "maximize"
    },
    resources={"budget": {"total": 100000}},
    item_requirements=[
        {"name": "seo", "budget": 25000},
        {"name": "content", "budget": 18000},
        # ... other channels
    ],
    monte_carlo_integration={
        "mode": "percentile",
        "percentile": "p50",
        "mc_output": mc_result
    }
)

# Validate robustness
robustness = test_assumption_robustness(
    base_answer=f"Allocate {opt_result['allocation']}",
    critical_assumptions=opt_result["monte_carlo_compatible"]["assumptions"],
    stress_test_ranges={
        "seo_conversion": {"low": 0.01, "high": 0.07}
    }
)

Result:
- Optimal: SEO 40%, Content 30%, Paid 20%, Email 8%, Events 2%
- Expected ROI: 2.5x
- Confidence: 87% chance of >2.0x ROI
- Risk: Breaks if SEO conversion < 2% (currently 4%)

依赖项

主控程序 >=0.9.0-模型上下文协议
浆 >=2.7.0-线性/整数规划
SciPy >=1.16.0-科学计算
数值Python >=2.3.0-数值数组
pytest >=7.0.0-测试框架

许可证

Claude Code MCP生态系统的一部分。负责任地使用。

支持

问题：报告Claude代码设置中的问题
文档：请参阅计划文件 ~/.claude/plans/resilient-frolicking-wreath.md
例子：检查 examples/ 完整工作流目录

第1周状态: ✓ 配备2个核心工具的生产就绪

下一篇：第2周-投资组合优化和调度工具

使用说明

优化MCP

快速启动（60秒）

1.安装依赖项（10秒）

2.测试它是否有效（10秒）

3.在克劳德代码中使用（30秒）

4.下一步（10秒）

概述

主要特点

帕累托前沿可视化

安装

通过插件市场（推荐）

手动安装

重要免责声明

软件保修

商业决策通知

财务建议免责声明

准确性和验证

工具

1. optimize_allocation

多目标优化

增强约束

2. optimize_robust

3. optimize_portfolio

4. optimize_schedule

5. optimize_execute

为什么optimize_excute是你的“逃生舱”

6. optimize_network_flow

7. optimize_pareto

可扩展性指南

优化分配

optimize_robust

优化投资组合

优化时间表

优化网络流

优化路径

优化_随机

优化_列_根

优化执行

性能提示

当您达到比例限制时

蒙特卡罗积分模式

模式摘要

模式类型A：百分比/预期（大多数工具）

模式类型B：情景（稳健和随机）

何时使用哪种模式

常见工作流

迁移指南

图式语法参考

资源定义

项目要求

目标规范

约束规范

网络规范

求解器选项

规范工作流程

工作流程1：优化→ 验证→ 稳健性检验

工作流程2:MC场景→ 稳健优化

技术架构

解算器

文件结构

绩效目标

故障排除

MCP未加载

无法解决的问题

缓慢解决

路线图

第2周（下一步）

第3周

例子

示例1：营销预算分配

依赖项

许可证

支持

相关 MCP

Pyomo优化库服务

工作流编排系统

优化工具服务器

飞机设计优化服务

代理交易API

1. `optimize_allocation`

2. `optimize_robust`

3. `optimize_portfolio`

4. `optimize_schedule`

5. `optimize_execute`

6. `optimize_network_flow`

7. `optimize_pareto`