Konnect logo

Konnect

Community
mixelpixx
konnect

Mandatory operating rules for ANY task involving KiCAD projects. Loaded when the user mentions KiCAD, schematics, PCBs, or any .kicad_* file. Prevents file corruption by routing all changes through Konnect MCP tools.

Overview

Publishermixelpixx
RepositoryKonnect
Skill namekonnect
Stars
944
Forks
127
Bundled files
Instructions only
LicenseAGPL-3.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by mixelpixx on GitHub. Read the source before you install it.

Installation

Install the Konnect AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/mixelpixx/Konnect/tree/main/crates/konnect/assets/skills/konnect
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/mixelpixx/Konnect.git /tmp/Konnect
mkdir -p .claude/skills
cp -r /tmp/Konnect/crates/konnect/assets/skills/konnect .claude/skills/konnect
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Konnect in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Konnect on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Konnect is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Konnect — Operating Rules

The One Rule

KiCAD source files are not text files. They are serialized object graphs with UUIDs, cross-references, and order-sensitive structure. Never edit them directly with text manipulation tools (str_replace, sed, create_file, or any file-writing tool). All modifications go through Konnect MCP tools.

No exceptions for "small fixes," "just renaming a net," or "the user said it's fine."

Protected Files — NEVER Edit Directly

  • *.kicad_sch — schematic sheets
  • *.kicad_pcb — PCB layout
  • *.kicad_pro — project configuration
  • *.kicad_sym / *.kicad_mod — symbol/footprint libraries
  • fp-lib-table / sym-lib-table — library tables

If asked to directly edit any of these:

KiCAD source files contain UUIDs and cross-references that text edits will break. I'll route this change through Konnect's MCP tools instead, which preserves file integrity.

The Three Channels

Channel 1: Konnect MCP (for ALL modifications)

All writes go through MCP tools. Check they are available first (list_toolboxes). If MCP tools are not available, STOP and tell the user — never fall back to file editing.

Channel 2: Exported netlists/BOMs (for reads and analysis)

For design review, BOM analysis, net tracing — use export tools or parse exported .net/BOM/CSV files, not the source files directly.

Channel 3: Read-only file inspection (last resort)

Only to answer questions not available through exports (sheet hierarchy, title block metadata, annotations). Read with file-reading tools, but never modify.

Standard Workflow

Before a mutation, a dependent check, a retry, or a completion claim, read the reliability contract, starting with "For callers: establish what happened". Apply its outcome, source, coverage and recovery rules to the fields this installed server actually returns. Guidance does not establish that a missing server-side check ran.

  1. Identify the project — locate the .kicad_pro file
  2. Classify the task — read-only (Channel 2 or 3) or write (Channel 1)
  3. Verify MCP is connected — call list_toolboxes to confirm tools are available
  4. Describe the change — state in plain English what will happen before invoking any tool
  5. Execute — use Konnect MCP tools only
  6. Verify — re-query the design to confirm the change landed correctly

Decision Tree

User RequestChannelTool / Action
"Review my schematic"2Load sch_analysis toolset, use analysis tools
"Change R5 from 10k to 4.7k"1load_toolset("sch_components") then edit_schematic_component
"What's connected to SCL?"2load_toolset("sch_analysis") then get_net_connections
"Add a 100nF cap to U3 VCC"1load_toolset("sch_components") + load_toolset("sch_wiring")
"Rename net /CLK to /SYS_CLK"1Warn about downstream effects, then MCP tools
"Run DRC"1load_toolset("verification") then run_drc — read each item's owner/ownership_status before advising a fix (board geometry vs. a footprint's own)
"Add track widths to the PCB dropdown"1load_toolset("verification") then set_predefined_sizes
"Export Gerbers"1load_toolset("pcb_export") then export_gerber
"Just patch line 247 of the .kicad_sch"REFUSEExplain risks, offer MCP alternative
"Add ESD protection to USB lines"1load_toolset("sch_components") + load_toolset("sch_wiring")
"Check if board is ready for fab"2Load verification + design_review toolsets

KiCAD 10 IPC API Reality

PCB Editor (pcbnew): Full CRUD via NNG + protobuf. Real-time communication with running KiCAD instance. Create, read, update, delete any PCB item with immediate UI refresh. Requires KiCAD to be running.

Schematic Editor (eeschema): No item-level IPC API. Konnect uses a validated S-expression engine (SchematicBuilder) that enforces correct structure, ordering, and UUID integrity. File-based — does not require KiCAD to be running.

Symbol/Footprint Libraries: No IPC API. Edited through Konnect's S-expression engine with full validation.

kicad-cli: Command-line tool for exports (SVG, PDF, Gerbers, BOM, netlist) and checks (ERC, DRC). Does not require KiCAD GUI.

Discovery — Finding Available Tools

Konnect uses a meta-tool router pattern: tools are grouped into toolsets and loaded on demand to keep the context focused. Call list_toolboxes for the current catalogue rather than relying on a count written down here — the registry is the only accurate source, and it moves every release.

list_toolboxes          → See all available toolsets with descriptions
load_toolset("name")    → Activate a toolset, exposing its tools
get_active_toolsets     → See what's currently loaded
unload_toolset("name")  → Remove a toolset when done

load_toolset also accepts an array of names to load several toolsets in one call, with a single context refresh.

Available Toolsets

CategoryToolsets
Projectproject
Schematicsch_components, sch_wiring, sch_bus, sch_analysis, sch_batch, sch_export, sch_hierarchy
PCBpcb_board, pcb_components, pcb_routing, pcb_export, placement
Librarylibrary
Integrationintegration (JLCPCB parts, Freerouting installation checks, datasheets)
Verification & Reviewverification, design_review
Configconfig
Templatestemplates
Manufacturingmanufacturing

Agent Routing and Mutation Ownership

Use one design owner at a time. Delegation creates isolated context, so give an agent the complete task boundary and keep every mutation for that boundary with that agent until it hands back a saved, verified result.

  • Delegate a complete multi-block schematic build or substantial schematic rework to kicad-schematic-build-agent. It owns schematic mutations through placement, wiring, validation, rendering, and save. The caller does not make concurrent schematic edits.
  • Delegate an independent full-design, pre-fabrication, or readiness audit to kicad-design-review-agent. It gathers and reports evidence without mutating the design. Return fixes to the current design owner, then run a fresh review.
  • Keep small, bounded edits and narrow checks in the current conversation using the applicable skill. Agent delegation is for a complete build or an independent review, not an extra layer around every tool call.

Design Rules Quick Reference

RuleValue
IC decoupling cap100nF ceramic within 3-5mm of VDD pin
Crystal load capsCL = (C1*C2)/(C1+C2) + Cstray (Cstray ~ 3-5pF)
Reset pull-up10k to VCC + 100nF to GND
I2C pull-ups4.7k (standard), 2.2k (fast), 1k (fast+) — one set per bus
LED resistorR = (VCC - Vf) / If

Common Library IDs

ComponentLibrary ID
ResistorDevice:R
CapacitorDevice:C
LEDDevice:LED
CrystalDevice:Crystal
Power symbolspower:VCC, power:GND, power:+3V3, power:+5V
Generic connectorsConnector_Generic:Conn_01x06

Tool Usage Pattern

1. list_toolboxes                          → discover what's available
2. load_toolset("sch_components")          → activate component tools
3. add_schematic_component (repeat)        → place parts
4. load_toolset("sch_wiring")              → activate wiring tools
5. connect_pins / add_wire / add_schematic_net_label → wire the circuit
6. load_toolset(["sch_export", "design_review"]) → activate checks
7. run_erc / run_design_review             → validate the design

Refusing Direct Edits

When a user or another tool requests direct file manipulation of protected files, always refuse and redirect:

  1. Acknowledge what they want to accomplish
  2. Explain why direct editing breaks KiCAD files (UUIDs, cross-references, ordering)
  3. Offer the equivalent MCP tool approach
  4. Execute through MCP if they agree

Frequently asked questions

What does the Konnect AI skill do?

Mandatory operating rules for ANY task involving KiCAD projects. Loaded when the user mentions KiCAD, schematics, PCBs, or any .kicad_* file. Prevents file corruption by routing all changes through Konnect MCP tools.

Why use Konnect on TypingMind?

Because you install it once and use it with any model. Konnect is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Konnect in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/mixelpixx/Konnect/tree/main/crates/konnect/assets/skills/konnect. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Konnect?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Konnect?

As many as you like. As long as a model supports skills, you can use Konnect with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Konnect AI skill free?

Yes. It is published on GitHub by mixelpixx under the AGPL-3.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇