graph TD
    User([User / MCP Client]) --> MCP[Decisify FastMCP Server]
    
    subgraph "FastMCP Interface Layer"
        MCP --> Decomp[decompose_optimization_query]
        MCP --> Tools[Modular Agent Tools]
        MCP --> Sandbox[execute_pyscipopt_sandbox]
        MCP --> Workflow[run_end_to_end_workflow]
    end

    subgraph "Autonomous Multi-Agent Graph (Strands Engine)"
        ReqClar[Requirements Clarifier Agent] --> ReqRev[Requirements Reviewer Agent]
        ReqRev -- "Needs Clarification" --> ReqClar
        ReqRev -- "Requirements Validated" --> MathProp[Math Model Proposer Agent]
        
        MathProp --> MathRev[Math Model Reviewer Agent]
        MathRev -- "Formulation Errors" --> MathProp
        MathRev -- "Math Model Approved" --> CodeGen[PySCIPOpt Model Coder Agent]
        
        CodeGen --> CodeRev[Model Code Reviewer Agent]
        CodeRev -- "Syntax / Logic Issue" --> MathProp
        CodeRev -- "Code Approved" --> CodeExec[Sandbox Code Executor Agent]
        
        CodeExec --> ExecRev[Execution Reviewer Agent]
        ExecRev -- "Runtime / Infeasible Error" --> CodeGen
        ExecRev -- "Optimal Solution Found" --> Output([Validated Solution & Report])
    end

    Workflow --> ReqClar
    Tools -.-> ReqClar
    Tools -.-> MathProp
    Tools -.-> CodeGen
    Tools -.-> CodeExec

# Clone the repository
git clone https://github.com/your-org/decisify.git
cd decisify

# Create and activate virtual environment
uv venv
source .venv/bin/activate

# Install dependencies
uv pip install -e ".[dev]"

python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

# For OpenAI / OpenRouter
export OPENAI_API_KEY="your-api-key"
export BASE_URL="https://openrouter.ai/api/v1"  # Optional override

# For Azure AI Foundry / Azure OpenAI
export BASE_URL="https://<your-resource-name>.openai.azure.com/openai/v1"
export OPENAI_API_KEY="your-azure-key"

# Run over stdio (default)
fastmcp run server.py:mcp

# Run as SSE server on port 8000
fastmcp run server.py:mcp --transport sse --host 0.0.0.0 --port 8000

# Run as Streamable HTTP server on port 8000
fastmcp run server.py:mcp --transport streamable-http --host 0.0.0.0 --port 8000

# Build the image
docker build -t decisify:latest .

# Run with stdio transport
docker run -i --rm -e OPENAI_API_KEY="$OPENAI_API_KEY" decisify:latest

# Run with Streamable HTTP transport (Port 8000)
docker run -i --rm \
  -p 8000:8000 \
  -e OPENAI_API_KEY="$OPENAI_API_KEY" \
  decisify:latest \
  --transport streamable-http \
  --host 0.0.0.0 \
  --port 8000

# Run with SSE transport (Port 8000)
docker run -i --rm \
  -p 8000:8000 \
  -e OPENAI_API_KEY="$OPENAI_API_KEY" \
  decisify:latest \
  --transport sse \
  --host 0.0.0.0 \
  --port 8000

{
  "mcpServers": {
    "decisify": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "fastmcp",
        "fastmcp",
        "run",
        "/absolute/path/to/decisify/server.py:mcp"
      ],
      "env": {
        "OPENAI_API_KEY": "your-api-key",
        "BASE_URL": "https://openrouter.ai/api/v1"
      }
    }
  }
}

{
  "mcpServers": {
    "decisify": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "OPENAI_API_KEY",
        "decisify:latest"
      ]
    }
  }
}

{
  "mcpServers": {
    "decisify": {
      "type": "sse",
      "url": "http://localhost:8000/sse"
    }
  }
}

{
  "mcpServers": {
    "decisify": {
      "command": "fastmcp",
      "args": ["run", "/absolute/path/to/decisify/server.py:mcp"],
      "env": {
        "OPENAI_API_KEY": "your-api-key"
      }
    }
  }
}

mcpServers:
  decisify:
    type: sse
    url: "http://localhost:8000/sse"

npx @modelcontextprotocol/inspector

# Run complete test suite with verbose output
pytest -v

# Run tests with coverage
pytest --cov=src --cov-report=term-missing

decisify/
├── src/
│   ├── agents.py         # 9 Strands modular agent definitions & prompts
│   ├── controllers.py    # Cyclic graph builder & conditional routing logic
│   ├── llms.py           # LLM client configuration & environment mappings
│   ├── models.py         # Pydantic schemas (FormulationIR, ExecutableModelCode)
│   ├── server.py         # FastMCP server registration (tools, resources, prompts)
│   └── tools.py          # Subprocess sandbox code execution runner
├── tests/
│   ├── test_agents.py       # Agent definition and tool binding tests
│   ├── test_controllers.py  # Graph topology, condition evaluation & routing tests
│   ├── test_models.py       # Pydantic schema validation & serialization tests
│   ├── test_server.py       # FastMCP tools, resources & prompt template tests
│   └── test_tools.py        # Sandbox execution & code extraction tests
├── Dockerfile            # Container definition with SCIP and FastMCP
├── pyproject.toml        # Build configuration, dependencies & metadata
├── server.py             # Server export entrypoint
├── CONTRIBUTING.md       # Contribution guidelines
└── LICENSE               # MIT License