calculate_torque

Instructions

Torque is the rotational equivalent of force. It causes angular acceleration
and depends on both the force magnitude and the distance from the pivot point.

Args:
    force_x: X component of force in Newtons
    force_y: Y component of force in Newtons
    force_z: Z component of force in Newtons
    position_x: X component of position vector from pivot to force application (meters)
    position_y: Y component of position vector from pivot to force application (meters)
    position_z: Z component of position vector from pivot to force application (meters)

Returns:
    Dict containing:
        - torque: Torque vector [x, y, z] in N⋅m
        - magnitude: Torque magnitude in N⋅m

Tips for LLMs:
    - Torque direction follows right-hand rule (perpendicular to force and position)
    - Maximum torque when force is perpendicular to position vector
    - Zero torque when force is parallel to position vector
    - Use for: wrenches, door hinges, motors, gears

Example - Opening a door:
    result = await calculate_torque(
        force_x=50.0,  # Push perpendicular to door
        force_y=0.0,
        force_z=0.0,
        position_x=0.0,
        position_y=0.0,
        position_z=0.8  # 0.8m from hinge
    )
    # Torque = 40 N⋅m

Implementation Reference

• src/chuk_mcp_physics/rotational.py:105-126 (handler)

  Core torque calculation logic: computes cross product r × F and magnitude

  def calculate_torque(request: TorqueRequest) -> TorqueResponse:
      """Calculate torque from force and position: τ = r × F (cross product).
  
      Args:
          request: Torque calculation request
  
      Returns:
          Torque vector and magnitude
      """
      r = request.position
      f = request.force
  
      # Cross product: r × F
      torque = [
          r[1] * f[2] - r[2] * f[1],  # x component
          r[2] * f[0] - r[0] * f[2],  # y component
          r[0] * f[1] - r[1] * f[0],  # z component
      ]
  
      magnitude = math.sqrt(sum(t * t for t in torque))
  
      return TorqueResponse(torque=torque, magnitude=magnitude)

• src/chuk_mcp_physics/rotational.py:17-31 (schema)

  Pydantic models for torque request (force + position vectors) and response (torque vector + magnitude)

  class TorqueRequest(BaseModel):
      """Request for torque calculation."""
  
      force: list[float] = Field(..., description="Force vector [x, y, z] in Newtons")
      position: list[float] = Field(
          ..., description="Position vector from pivot to force application [x, y, z] in meters"
      )
  
  
  class TorqueResponse(BaseModel):
      """Response for torque calculation."""
  
      torque: list[float] = Field(..., description="Torque vector [x, y, z] in N⋅m")
      magnitude: float = Field(..., description="Torque magnitude in N⋅m")

• src/chuk_mcp_physics/tools/rotational.py:8-59 (handler)

  MCP tool endpoint: wraps the core calculate_torque with individual float params, decorated with @tool

  @tool  # type: ignore[arg-type]
  async def calculate_torque(
      force_x: float,
      force_y: float,
      force_z: float,
      position_x: float,
      position_y: float,
      position_z: float,
  ) -> dict:
      """Calculate torque from force and position: τ = r × F (cross product).
  
      Torque is the rotational equivalent of force. It causes angular acceleration
      and depends on both the force magnitude and the distance from the pivot point.
  
      Args:
          force_x: X component of force in Newtons
          force_y: Y component of force in Newtons
          force_z: Z component of force in Newtons
          position_x: X component of position vector from pivot to force application (meters)
          position_y: Y component of position vector from pivot to force application (meters)
          position_z: Z component of position vector from pivot to force application (meters)
  
      Returns:
          Dict containing:
              - torque: Torque vector [x, y, z] in N⋅m
              - magnitude: Torque magnitude in N⋅m
  
      Tips for LLMs:
          - Torque direction follows right-hand rule (perpendicular to force and position)
          - Maximum torque when force is perpendicular to position vector
          - Zero torque when force is parallel to position vector
          - Use for: wrenches, door hinges, motors, gears
  
      Example - Opening a door:
          result = await calculate_torque(
              force_x=50.0,  # Push perpendicular to door
              force_y=0.0,
              force_z=0.0,
              position_x=0.0,
              position_y=0.0,
              position_z=0.8  # 0.8m from hinge
          )
          # Torque = 40 N⋅m
      """
      from ..rotational import TorqueRequest, calculate_torque as calc_torque
  
      request = TorqueRequest(
          force=[force_x, force_y, force_z],
          position=[position_x, position_y, position_z],
      )
      response = calc_torque(request)
      return response.model_dump()

• src/chuk_mcp_physics/tools/__init__.py:30-64 (registration)

  Tools package imports rotational module, which registers the @tool decorated calculate_torque via server.py's import

  from . import (
      basic,
      circular_motion,
      collisions,
      conservation,
      fluid,
      kinematics_tools,
      oscillations,
      rotational,
      statics,
  )
  
  __all__ = [
      "rotational",
      "oscillations",
      "circular_motion",
      "collisions",
      "conservation",
      "kinematics_tools",
      "statics",
      "fluid",
      "basic",
  ]

• src/chuk_mcp_physics/server.py:39-50 (registration)

  server.py imports tools.rotational module, triggering @tool registration of calculate_torque as an MCP tool

  from .tools import (
      basic,
      rotational,
      oscillations,
      circular_motion,
      collisions,
      conservation,
      fluid as fluid_tools,
      kinematics_tools,
      statics,
      convert_units as unit_conversion_tools,
  )