From Design Engineer to AI Engineer in CAD

The stack you are building

• CAD layer (C#): SolidWorks API, add-in, Model to JSON extractor, rule checker (Stages 1 and 2)
• Bridge: JSON files, FastAPI service, local HTTP endpoint in the add-in (Stages 2 and 3)
• Model layer (Python): LLM API calls, structured output, pydantic validation (Stage 4)
• Knowledge layer: Embeddings, vector store, hybrid search, RAG with citations (Stages 5 and 6)
• Agent layer: Tool calling, MCP server, approvals, logs (Stage 7)
• Production: Evals, tracing, cost caps, privacy, deployment (Stage 8)

Stage 0: Engineering foundation (1 to 2 weeks)

You already own this. It is the data and the rules every later stage runs on.

Learn

Design intent and parametric logic. Your team's drawing standards, templates, custom property names, revision scheme, and folder structure.

Do this, in order

1. List every custom property your templates use and who fills each one.
2. Write 10 rules your team applies by habit as if/then statements (for example: if sheet metal, then thickness property is required).
3. Collect your standards PDFs and 20 real questions engineers ask about them. You will reuse both in Stages 5 and 6.

Done when: Your team's drawing rules exist as plain if/then statements, not just in people's heads.

Stage 1: C# fundamentals (3 to 4 weeks)

SolidWorks, Inventor, AutoCAD, and Revit APIs are all built for .NET. C# is the most direct way in.

Learn

Visual Studio 2022. .NET Framework 4.8 (most CAD add-ins) and modern .NET. Types, classes, interfaces, List, Dictionary, LINQ, exceptions, try/finally. JSON with System.Text.Json or Newtonsoft.Json. NuGet. The debugger: breakpoints, watch, call stack.

Do this, in order

1. Build a console app that reads a BOM CSV into a List of BomLine objects.
2. Validate part numbers with Regex and print every failure with its row number.
3. Group and count by material with LINQ.
4. Write the results to a JSON file.
5. Step through it in the debugger until you can explain every variable.

Done when: You can write a class, a loop, and a LINQ query without copying.

Stage 2: CAD API with C# (6 to 8 weeks)

This is the layer AI will eventually drive. If you cannot write these calls, an AI agent has nothing to call.

Learn

COM interop references (SolidWorks.Interop.sldworks, swconst). The object model: SldWorks, ModelDoc2, ModelDocExtension, CustomPropertyManager, FeatureManager, SelectionMgr, DrawingDoc, Sheet, View. The API help and recorded macros as your map. Same pattern elsewhere: Inventor.Application, AutoCAD .NET (Database, Transaction), Revit API (FilteredElementCollector).

Do this, in order

1. Connect to a running SolidWorks session and print the active document title.
2. Open files with OpenDoc6. Read and write custom properties with CustomPropertyManager Get6 and Add3.
3. Walk the feature tree with FirstFeature and GetNextFeature. Read dimensions with Parameter("D1@Sketch1").
4. Export drawings to PDF with Extension.SaveAs. Read mass and volume with CreateMassProperty.
5. Package it as an add-in (ISwAddin, ConnectToSW) with one ribbon button and a log file.

Done when: You can extract 100 parts to JSON in one run and fix any COM error from the stack trace.

Stage 3: Python for AI (3 to 4 weeks)

LLM SDKs, embedding models, vector databases, and agent frameworks are Python-first. Keep C# for CAD, use Python for AI, and connect them with JSON or HTTP.

Learn

Python 3.11+, virtual environments (venv or uv), pip. Lists, dicts, functions, classes, pathlib, json. httpx or requests. pydantic for data validation. pandas for tables. FastAPI for small HTTP services. Jupyter for experiments. Optional: pywin32 to call SolidWorks COM from Python (fine for scripts, awkward with ref parameters, so keep heavy CAD work in C#).

Do this, in order

1. Load every Stage 2 JSON file into a pandas DataFrame.
2. Define a pydantic Part model and reject files that fail validation.
3. Report inconsistencies: one material spelled three ways, missing part numbers, mass outliers.
4. Serve the data with FastAPI: GET /parts?material=S355.

Done when: A teammate can query your CAD data from a browser without opening CAD.

Stage 4: LLM APIs (3 to 4 weeks)

Before RAG or agents, learn what one model call costs, what it returns, and how it fails.

Learn

Messages (system, user, assistant). Tokens, context window, temperature, cost per token. Streaming, retries, rate limits. Structured output with JSON schema or pydantic models. Few-shot prompts. SDKs: anthropic, openai. Local models with Ollama when CAD data cannot leave the building.

Do this, in order

1. Get an API key and send your first message from Python.
2. Ask for JSON output, validate it with pydantic, and retry on failure.
3. Build a few-shot prompt from 5 real examples out of your own drawings.
4. Log tokens and cost for every call.
5. Run the same prompt on a local model through Ollama and compare quality.

Done when: Every LLM output in your code passes a schema and a rule. Nothing raw gets trusted.

Stage 5: Embeddings and vector search (2 to 3 weeks)

LLMs do not know your standards, past designs, or API docs. Embeddings turn text into vectors so you can find the right content by meaning, not keywords.

Learn

What an embedding is. Cosine similarity. Chunking: split by heading, roughly 300 to 800 tokens, small overlap. Embedding models: text-embedding-3-small, Voyage, or open source sentence-transformers (bge-small). Vector stores: Chroma or FAISS to start, pgvector or Qdrant for production. Metadata on every chunk: source, page, revision.

Do this, in order

1. Extract text from your standards PDFs and the CAD API help with PyMuPDF.
2. Chunk by section and attach source and page metadata.
3. Embed the chunks and store them in Chroma.
4. Query "revision format for sheet metal drawings" and read the top 5 chunks by hand.
5. Tune chunk size until the right clause lands in the top 3.

Done when: For your 20 real questions from Stage 0, the right chunk is in the top 3 at least 17 times.

Stage 6: RAG (3 to 4 weeks)

Retrieval-augmented generation puts the right chunks in front of the model so answers come from your standards, with citations.

Learn

The pipeline: ingest, chunk, embed, store, retrieve, rerank, prompt with context, answer with citations. Hybrid search (BM25 keyword plus vector), which matters for part numbers and API names. Reranking. Metadata filters. Saying "I don't know" when nothing relevant comes back. Scoring retrieval and answers separately. LlamaIndex or LangChain, but only after you have built it by hand.

Do this, in order

1. Build the pipeline in plain Python first, no framework.
2. Force citations: every answer names the source document and page.
3. Add BM25 hybrid search so OpenDoc6 or PN-10432 match exactly.
4. Write a 30-question test set with expected answers and score it after every change.
5. Add a second index over part metadata from Stage 3: "find similar brackets, 3 mm, S355".

Done when: You track test-set scores and can label every wrong answer as a retrieval miss or a generation miss.

Stage 7: Tool calling and agents (4 to 6 weeks)

RAG answers questions. Agents take actions. This is where an LLM starts calling the C# code you wrote in Stage 2.

Learn

Tool calling: tools defined with JSON schema, the model requests a call, your code runs it, the result goes back. The agent loop and stop conditions. MCP (Model Context Protocol) servers to expose tools to any compatible client. Bridging Python to CAD: a C# add-in hosting a local HTTP endpoint or named pipe, or pywin32. State and memory. Frameworks later: LangGraph, OpenAI Agents SDK, Claude Agent SDK.

Do this, in order

1. Write the agent loop by hand with two read-only tools: get_properties(path) and search_standards(query).
2. Expose your Stage 2 extractor and checker as a local HTTP service and call it from Python.
3. Wrap the tools in an MCP server (Python MCP SDK, FastMCP): list_drawings, check_drawing, get_properties, search_standards.
4. Add write tools such as set_property only behind dry-run and human approval.
5. Add limits: max steps, timeouts, and a log of every tool call with its arguments.

Done when: You can replay the log of any run and explain why each tool was called.

Stage 8: Evaluate, ship, go deeper (ongoing)

A demo works once. A tool works every Monday morning. The difference is measurement.

Learn

Evals: fixed test sets, regression runs, LLM-as-judge used carefully. Tracing with Langfuse or LangSmith. Cost and latency budgets. Data privacy: customer IP, on-prem or local models, access control. Deployment: FastAPI plus Docker, background jobs. Going deeper: B-Rep and kernels (OpenCascade, pythonOCC), code-generated CAD (CadQuery, build123d) for text-to-CAD, ML on geometry.

Do this, in order

1. Run your Stage 6 and 7 test sets automatically on every change.
2. Trace every LLM call and tool call.
3. Set a cost cap per run and alert when it is exceeded.
4. Pilot with three real users for two weeks and log every failure.
5. Try one text-to-CAD experiment: the LLM writes CadQuery code for a simple bracket and you validate the geometry.

Done when: You can show the numbers, and show exactly where the AI stops and your rules take over.

Your toolkit at a glance

Six traps that stall the climb

• Starting with agents. An agent with no CAD API underneath can only talk. Stage 2 is what gives it hands.
• Skipping the JSON bridge. If your CAD data is not extracted and structured, RAG and agents have nothing reliable to work with.
• Trusting raw LLM output. Every output passes a schema and a rule before it touches a model or drawing.
• Using a framework before building by hand. Build RAG and the agent loop in plain Python once. Then frameworks make sense.
• No test set. Without 30 real questions and expected answers you cannot tell if a change made things better or worse.
• Sending customer IP to a public API. Check what data may leave the building. Use local models where it cannot.