Create a new blank KiCAD schematic.

Args: name: Project name for the schematic

Returns: Dictionary with success status and schematic information

Examples: >>> result = await create_schematic("MyProject") >>> print(result['message']) Created new schematic: MyProject

Load an existing KiCAD schematic file.

Args: file_path: Absolute path to .kicad_sch file

Returns: Dictionary with success status and schematic information

Examples: >>> result = await load_schematic("/path/to/project.kicad_sch") >>> print(f"Loaded: {result['project_name']}")

Save the current schematic to disk.

Args: file_path: Optional path to save to. If not provided, saves to original location.

Returns: Dictionary with success status

Examples: >>> # Save to original location >>> result = await save_schematic()

>>> # Save to new location
>>> result = await save_schematic("/path/to/new_location.kicad_sch")

Get information about the currently loaded schematic.

Returns: Dictionary with schematic metadata

Examples: >>> result = await get_schematic_info() >>> print(f"Components: {result['component_count']}")

Get comprehensive pin information for a component.

Returns all pins for the specified component with complete metadata including positions, electrical types, and pin names. Positions are in absolute schematic coordinates accounting for component rotation.

Args: reference: Component reference designator (e.g., "R1", "U2", "IC1") ctx: MCP context for progress reporting (optional)

Returns: ComponentPinsOutput with all pin information, or ErrorOutput on failure

Examples: >>> # Get all pins for a resistor >>> result = await get_component_pins("R1") >>> print(f"Found {result.pin_count} pins")

>>> # Get pins for an IC
>>> result = await get_component_pins("U1")
>>> for pin in result.pins:
...     print(f"Pin {pin.number}: {pin.name} @ ({pin.position.x}, {pin.position.y})")

Find pin numbers matching a name pattern.

Supports wildcard patterns (e.g., "CLK*", "IN") for semantic pin lookup. By default, matching is case-insensitive for maximum flexibility.

Args: reference: Component reference designator (e.g., "R1", "U2") name_pattern: Name pattern to search for (e.g., "VCC", "CLK*", "IN") case_sensitive: If True, matching is case-sensitive (default: False) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with pin_numbers list and metadata, or error information

Examples: >>> # Find all clock pins >>> result = await find_pins_by_name("U1", "CLK*") >>> print(f"Clock pins: {result['pin_numbers']}")

>>> # Find power pins (case-insensitive)
>>> result = await find_pins_by_name("U1", "vcc")
>>> print(f"VCC pins: {result['pin_numbers']}")

Find pin numbers by electrical type.

Returns all pins of a specific electrical type (e.g., all inputs, all power pins).

Args: reference: Component reference designator (e.g., "R1", "U2") pin_type: Electrical type filter. Must be one of: "input", "output", "bidirectional", "passive", "power_in", "power_out", "open_collector", "open_emitter", "tri_state", "unspecified", "free", "no_connect" ctx: MCP context for progress reporting (optional)

Returns: Dictionary with pin_numbers list and metadata, or error information

Examples: >>> # Find all input pins >>> result = await find_pins_by_type("U1", "input") >>> print(f"Input pins: {result['pin_numbers']}")

>>> # Find all power input pins
>>> result = await find_pins_by_type("U1", "power_in")
>>> print(f"Power pins: {result['pin_numbers']}")

Add a component to the current schematic.

Creates a new component with the specified library ID, value, and optional parameters. If no reference is provided, one will be auto-generated based on the component type (e.g., R1, C1, U1). If no position is provided, the component will be auto-placed.

Args: lib_id: Library identifier (e.g., "Device:R", "Amplifier_Operational:TL072") value: Component value or part description (e.g., "10k", "100nF", "TL072") reference: Component reference designator (e.g., "R1", "U2") - auto-generated if None position: Component position as (x, y) tuple in mm - auto-placed if None rotation: Component rotation in degrees (0, 90, 180, or 270), defaults to 0 footprint: PCB footprint identifier (e.g., "Resistor_SMD:R_0603_1608Metric") ctx: MCP context for progress reporting (optional)

Returns: ComponentInfoOutput with component information, or ErrorOutput on failure

Examples: >>> # Add a resistor with auto-generated reference >>> result = await add_component( ... lib_id="Device:R", ... value="10k", ... position=(100.0, 100.0) ... ) >>> print(f"Added {result.reference}")

>>> # Add a capacitor with specific reference and footprint
>>> result = await add_component(
...     lib_id="Device:C",
...     value="100nF",
...     reference="C1",
...     position=(120.0, 100.0),
...     footprint="Capacitor_SMD:C_0603_1608Metric"
... )

List all components in the current schematic.

Returns all components with their complete metadata including position, rotation, footprint, and properties.

Args: ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and list of components, or error information

Examples: >>> result = await list_components() >>> print(f"Found {result['count']} components") >>> for comp in result['components']: ... print(f"{comp['reference']}: {comp['value']}")

Update component properties.

Updates one or more properties of an existing component. Only provided parameters will be updated.

Args: reference: Component reference designator to update (e.g., "R1") value: New component value (if provided) position: New position as (x, y) tuple in mm (if provided) rotation: New rotation in degrees (0, 90, 180, or 270) (if provided) footprint: New footprint identifier (if provided) ctx: MCP context for progress reporting (optional)

Returns: ComponentInfoOutput with updated component information, or ErrorOutput on failure

Examples: >>> # Update value only >>> result = await update_component("R1", value="20k")

>>> # Update multiple properties
>>> result = await update_component(
...     "R1",
...     value="20k",
...     footprint="Resistor_SMD:R_0805_2012Metric",
...     rotation=90.0
... )

Remove a component from the schematic.

Removes the component with the specified reference designator. This also removes all associated wires and connections.

Args: reference: Component reference designator to remove (e.g., "R1") ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status

Examples: >>> result = await remove_component("R1") >>> if result['success']: ... print(f"Removed component {result['reference']}")

Filter components by various criteria.

Returns components matching the specified filter criteria. All provided criteria must match (AND logic).

Args: lib_id: Filter by library ID (exact match, e.g., "Device:R") value: Filter by value (exact match, e.g., "10k") value_pattern: Filter by value pattern (substring match, e.g., "10") footprint: Filter by footprint (exact match) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and list of matching components

Examples: >>> # Find all resistors >>> result = await filter_components(lib_id="Device:R") >>> print(f"Found {result['count']} resistors")

>>> # Find all 10k resistors
>>> result = await filter_components(lib_id="Device:R", value="10k")

>>> # Find all components with "100" in value
>>> result = await filter_components(value_pattern="100")

Add a wire between two points.

Creates a wire connection between start and end points. Wires are used to connect component pins and establish electrical nets.

Args: start: Start point as (x, y) tuple in mm end: End point as (x, y) tuple in mm ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and wire information

Examples: >>> # Connect two points horizontally >>> result = await add_wire( ... start=(100.0, 100.0), ... end=(150.0, 100.0) ... )

>>> # Vertical wire
>>> result = await add_wire(
...     start=(100.0, 100.0),
...     end=(100.0, 150.0)
... )

Add a net label to the schematic.

Net labels are used to name electrical nets and establish connections between non-physically connected wires with the same label name.

Args: text: Label text (net name) position: Label position as (x, y) tuple in mm rotation: Label rotation in degrees (0, 90, 180, 270), defaults to 0 size: Text size in mm, defaults to 1.27 (KiCAD standard) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and label information

Examples: >>> # Add VCC label >>> result = await add_label( ... text="VCC", ... position=(100.0, 100.0) ... )

>>> # Add label with rotation
>>> result = await add_label(
...     text="GND",
...     position=(150.0, 100.0),
...     rotation=90.0
... )

Add a wire junction at the specified position.

Junctions indicate T-connections where three or more wires meet. They are required in KiCAD when a wire branches into multiple paths.

Args: position: Junction position as (x, y) tuple in mm diameter: Junction diameter in mm (0 = use KiCAD default) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and junction information

Examples: >>> # Add junction at T-connection >>> result = await add_junction( ... position=(100.0, 100.0) ... )

>>> # Add junction with custom diameter
>>> result = await add_junction(
...     position=(150.0, 100.0),
...     diameter=0.8
... )

Connect two component pins with automatic orthogonal routing.

Uses Manhattan-style (orthogonal) routing to create L-shaped or direct wire paths between component pins. Automatically calculates pin positions and generates appropriate wire segments with optional junctions and labels.

Args: from_component: Source component reference (e.g., "R1") from_pin: Source pin number (e.g., "2") to_component: Destination component reference (e.g., "R2") to_pin: Destination pin number (e.g., "1") corner_direction: Routing direction preference: - "auto": Smart heuristic (horizontal if dx >= dy, else vertical) - "horizontal_first": Route horizontally then vertically - "vertical_first": Route vertically then horizontally add_label: Optional net label text to add at start of routing add_junction: Whether to add junction at L-shaped corners (default: True) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and connection information including: - from/to component and pin details with positions - routing type (direct or L-shaped) - segments list with start/end positions - wire_uuids list - junction_uuid (if junction was added) - label_uuid (if label was added)

Examples: >>> # Simple connection with auto routing >>> result = await connect_components("R1", "2", "R2", "1")

>>> # With label and horizontal-first routing
>>> result = await connect_components(
...     "R1", "2", "R2", "1",
...     corner_direction="horizontal_first",
...     add_label="VCC"
... )

>>> # Vertical-first without junction
>>> result = await connect_components(
...     "R1", "1", "C1", "1",
...     corner_direction="vertical_first",
...     add_junction=False
... )

Add a bus wire between two points.

Bus wires represent multi-bit signal connections (e.g., data buses, address buses). They are visually thicker than regular wires and use different styling in KiCAD.

Args: start: Start point as (x, y) tuple in mm end: End point as (x, y) tuple in mm ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and bus wire information

Examples: >>> # Create 8-bit data bus >>> result = await add_bus_wire( ... start=(50.0, 50.0), ... end=(100.0, 50.0) ... )

Add a bus entry to the schematic.

Bus entries connect individual wires to bus wires. They are typically placed at a 45-degree angle and show where a single signal branches off from a multi-bit bus.

Args: position: Entry point as (x, y) tuple in mm rotation: Rotation angle in degrees (0, 90, 180, 270), defaults to 0 ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and bus entry information

Examples: >>> # Add bus entry at position with 270 degree rotation >>> result = await add_bus_entry( ... position=(60.0, 50.0), ... rotation=270 ... )

Add a bus label to the schematic.

Bus labels identify multi-bit signals using range notation. Examples: "DATA[0..7]", "ADDR[0..15]", "RGB[R,G,B]"

Args: text: Label text with bus notation (e.g., "DATA[0..7]") position: Label position as (x, y) tuple in mm rotation: Label rotation in degrees (0, 90, 180, 270), defaults to 0 size: Text size in mm, defaults to 1.27 (KiCAD standard) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and bus label information

Examples: >>> # Add 8-bit data bus label >>> result = await add_bus_label( ... text="DATA[0..7]", ... position=(75.0, 48.0) ... )

>>> # Add RGB bus label
>>> result = await add_bus_label(
...     text="RGB[R,G,B]",
...     position=(100.0, 50.0)
... )

Manage schematic project (create, read, save, load).

Args: action: Operation to perform ("create", "read", "save", "load") name: Project name (required for "create") file_path: File path (required for "load"/"save", optional for others) ctx: MCP context for progress reporting (optional)

Returns: Dictionary with success status and operation results

Manage components (add, list, get_pins, update, remove).

Args: action: Operation ("add", "list", "get_pins", "update", "remove") lib_id: Library ID (required for "add") value: Component value (required for "add") reference: Reference designator (optional for "add", required for others) position: Position tuple (for "add"/"update") rotation: Rotation in degrees (for "add"/"update") footprint: Footprint string (for "add"/"update") ctx: MCP context (optional)

Returns: Dictionary with component data or error

Manage wires (add, remove).

Args: action: Operation ("add", "remove") start: Start point (required for "add") end: End point (required for "add") wire_uuid: Wire UUID (required for "remove") ctx: MCP context (optional)

Returns: Dictionary with wire data or error

Manage labels (add, remove).

Args: action: Operation ("add", "remove") text: Label text (required for "add") position: Position (required for "add") rotation: Rotation in degrees (optional) label_uuid: Label UUID (required for "remove") ctx: MCP context (optional)

Returns: Dictionary with label data or error

Manage text boxes (add, update, remove).

Args: action: Operation ("add", "update", "remove") text: Text content (required for "add", optional for "update") position: Position (required for "add") size: Size tuple (required for "add") rotation: Rotation in degrees (optional) font_size: Font size (optional) text_box_uuid: TextBox UUID (required for "update"/"remove") ctx: MCP context (optional)

Returns: Dictionary with text box data or error

Manage power symbols (add, list, remove).

Args: action: Operation ("add", "list", "remove") power_net: Power net name (required for "add") position: Position (required for "add") symbol_variant: Symbol variant (optional) power_symbol_uuid: Power symbol UUID (required for "remove") ctx: MCP context (optional)

Returns: Dictionary with power data or error

Manage hierarchical sheets (add, set_context, list, remove, add_pin, remove_pin).

Args: action: Operation ("add", "set_context", "list", "remove", "add_pin", "remove_pin") name: Sheet name (required for "add") filename: Filename (required for "add") position: Position (required for "add") size: Size (required for "add") project_name: Project name (optional for "add") parent_uuid: Parent UUID (required for "set_context") sheet_uuid: Sheet UUID (required for "set_context"/"remove"/"add_pin"/"remove_pin") pin_name: Pin name (required for "add_pin") pin_type: Pin electrical type (required for "add_pin") edge: Pin edge placement (required for "add_pin") position_along_edge: Distance along edge in mm (required for "add_pin") pin_uuid: Pin UUID (required for "remove_pin") ctx: MCP context (optional)

Returns: Dictionary with sheet data or error

Manage global labels (add, remove).

Args: action: Operation ("add", "remove") text: Label text (required for "add") position: Position (required for "add") shape: Label shape (optional) rotation: Rotation in degrees (optional) label_uuid: Label UUID (required for "remove") ctx: MCP context (optional)

Returns: Dictionary with label data or error

Manage hierarchical labels (add, remove).

Hierarchical labels connect child schematics to parent sheet pins. They enable signal routing through hierarchical sheet boundaries.

Args: action: Operation ("add", "remove") text: Label text (required for "add") position: Position (required for "add") shape: Label shape - "input", "output", "bidirectional", "tri_state", "passive" (optional) rotation: Rotation in degrees (optional) size: Text size in mm (optional, default: 1.27) label_uuid: Label UUID (required for "remove") ctx: MCP context (optional)

Returns: Dictionary with label data or error