Insights

AI for Construction and Engineering Documents

A local model can search the spec book and RFI log, flag text changes between drawing revisions and pull door schedules out of PDFs. Reading the drawings themselves is still a job for people.

Share:
AI for Construction and Engineering Documents

Picture a mid-size commercial job: a 1,400-page project manual, 220 drawing sheets, 380 RFIs and 260 submittals by the time the building tops out. A project engineer who needs to know whether the fire-rated door frames were ever changed has to check the spec section, three addenda, a handful of RFI answers and the latest door schedule. That is the problem AI for construction documents can actually help with: finding and cross-checking text that already exists. It is much weaker at the thing people often expect first, which is reading the drawings.

The working rule: text a model can find, quote and compare is fair game on a local server; meaning carried only by lines, symbols and scale still needs a person.

Why project files belong on your own server

Construction documents are full of other people's property. US copyright law defines an architectural work as "the design of a building as embodied in any tangible medium of expression, including a building, architectural plans, or drawings" (17 U.S.C. 101). Standard owner-architect agreements reinforce this. The AIA's own guidance on its B101-2017 owner-architect form states that "the Architect and the Architect's consultants are deemed the authors and owners of their respective Instruments of Service," and that the owner receives a license to use them solely for constructing, using, maintaining, altering and adding to the project (AIA Contract Documents).

So a general contractor holding a full drawing set is holding a licensed copy for one purpose. Many projects add an NDA on top, especially data centers, labs, banks, correctional facilities and anything with security systems shown on the plans. Some owners forbid uploading project documents to any outside service without written approval.

Uploading those files to a consumer AI tool raises questions nobody on the team can answer quickly: does the license allow it, does the NDA, what does the vendor keep? A model running on a server in the office, with no outbound connection, removes the question. This is general information, not legal advice; the contract and the NDA on each project decide what is allowed.

Searching specs, RFIs and submittals

The search job is the standard retrieval pattern: split documents into passages, index them, find the passages that match a question and have the model answer from those passages with citations. What makes construction different is the structure of the documents and how often they are superseded.

Specifications

Most North American specs follow CSI MasterFormat, which organizes content into 50 divisions (00 through 49) with section numbers of six to ten digits, the common six-digit form looking like 08 71 00 (WBDG summary of MasterFormat). That numbering is a gift for retrieval. Split the manual by section rather than by fixed character count, and store the section number, title, part (General, Products, Execution) and issue date as metadata on every chunk.

People search with exact strings: section numbers, product model numbers, ASTM designations, fire ratings. Pure vector search tends to blur these together, which is why construction is one of the clearest cases for combining keyword and vector search. A query for "08 71 00 closer" should hit the hardware section first, not a paragraph that merely talks about doors.

RFIs and their answers

An RFI log is a record of how the design changed after bid. The useful question is rarely "what does RFI 214 say" but "has anything changed the requirement in section 09 21 16," and the answer may sit in an RFI response that never mentions the section number.

Two practices make this work:

  • Index the question and the answer together, with the RFI number, date, status and the sheets or sections it references.
  • Rank by date and authority. When the spec and an RFI answer disagree, the answer should show both and note which is newer. The model should not silently pick one. Contract hierarchy decides, and that is a human call.

Submittal checks

A submittal review is a comparison: does the product data match what the spec section requires? A local model can do a useful first pass. Give it the Products part of the spec section and the extracted text of the product data sheet, and ask it to list each stated requirement with "met", "not met" or "not found" and the page where it found the evidence.

The output is a checklist for the reviewer, not a stamp. Product data often arrives as scanned PDFs, so OCR quality matters; local OCR and document extraction covers getting clean text out of them.

Comparing drawing revisions by their text

Reissued sheets are where time disappears. Suppose Addendum 3 reissues 180 sheets and a reviewer spends 10 minutes per sheet looking for clouds and comparing notes. That is 180 x 10 = 1,800 minutes, or 30 hours. If an automated pass shows that only 45 of those sheets have any changed text, the reviewer can start with those 45 and skim the rest.

Drawings exported from CAD or BIM software usually keep a real text layer in the PDF. A library such as PyMuPDF can pull every word with its position on the page as (x0, y0, x1, y1, word, ...) tuples (PyMuPDF text extraction docs). With words and coordinates for revision B and revision C of the same sheet, a script can report:

  • notes added, removed or reworded
  • dimension strings that changed, such as 12'-6" becoming 12'-0"
  • tags and callouts that moved or disappeared
  • title block changes (revision number, date, sheet title)

The language model's role is the last step: turning a raw diff of 60 changed words into a readable summary per sheet ("General note 4 now requires 5/8 in. Type X board at corridor walls; door tag 114B removed"). The comparison itself should be plain code, because it is exact and repeatable.

The limit is obvious once stated. A text diff sees nothing that is not text. A wall moved 6 inches with its dimension string unchanged, a duct rerouted, a hatch pattern swapped: none of these show up. Overlay comparison of the graphics remains a separate tool, and this text pass only tells the reviewer where to look first.

Pulling schedules and quantities out of PDFs

Schedules are tables, and tables carry the numbers people retype most: door schedules, hardware sets, finish schedules, equipment and fixture schedules, panel schedules. Getting them into a spreadsheet is a strong use case because the result is easy to verify.

On a vector PDF, the text is already there; the work is reconstructing rows and columns. PyMuPDF's find_tables() detects grid lines from the vector graphics by default, and offers a "text" strategy that infers columns from word alignment for schedules drawn without ruling lines. Borderless schedules need more checking. A language model then helps with the messy parts: merged header cells, abbreviations like "HM" and "WD", footnote markers, and mapping each schedule's column names onto a standard set of fields. If the output must follow a fixed shape, constrained JSON output keeps every row in the same structure.

Every extracted schedule needs a check that does not depend on the model:

  1. Count check. If the door schedule lists 312 doors, the extracted rows must total 312.
  2. Cross-reference check. Every hardware set number in the door schedule must exist in the hardware schedule.
  3. Plan check. Door tags found in the plan sheets' text layer should match the schedule's tags. A tag on the plan but missing from the schedule is exactly the kind of coordination error worth an RFI.

Quantities are a different matter. Counts that live in a schedule can be extracted. Quantities that live only in the geometry, such as square footage of flooring or linear feet of wall, cannot come from text at all. That is takeoff software's job, working from the vector geometry or a model file, and a language model does not replace it.

Why the drawings themselves are still hard

It is tempting to hand a sheet to a vision model and ask how many outlets are in room 214. Current vision-language models can describe a drawing in broad terms and read a title block or a legible note. What they do poorly is exactly what a drawing exists for:

  • Scale and measurement. A model looking at a raster image has no reliable sense of distance. Reading a dimension string is possible; inferring an undimensioned length is guesswork.
  • Symbols in context. The same circle with a letter means different things on electrical, mechanical and fire protection sheets, defined in a legend on another sheet.
  • Cross-references. Detail 5 on A-501 is called out from A-201. Understanding the building means following those references across dozens of sheets.
  • Resolution. A 36 x 48 in. sheet downsampled to fit a model's image input loses the small text that matters most. Tiling the sheet helps reading, but breaks the spatial picture.

The practical stance is to treat drawings as documents the system can find, cite and diff, not documents it interprets. For what image-and-question models can handle, see local vision-language models.

A sensible first project

All of the jobs above fit on a single office server with one capable GPU, because queries are short and a project team is a few dozen people at most. Start with search over the spec book and RFI log of one active project. Write down 30 questions the project engineers actually asked last month, along with the section or RFI that answers each one. If the system finds the right source for most of them and cites it, add submittal first-pass checks next, then schedule extraction, each with its own small test set.

Frequently asked questions

Does a BIM model make any of this easier than PDFs?

Yes, for quantities and schedules. A model file holds element types, counts and properties as data, so a script can read them directly with no extraction step. PDFs remain the record for most contract communication, though, so search and revision checks still run on them.

Can a local model write RFI responses?

It can draft the wording from the design team's notes and cite the relevant spec sections and sheets. The design decision in the answer belongs to the architect or engineer of record, who carries the professional responsibility for it.

What about old projects that exist only as scanned drawings?

Scans have no text layer, so search and diffing depend on OCR, which handles notes and title blocks reasonably and small dimension text poorly. Indexing title blocks and general notes from an archive is still useful for finding the right set.

Should every project get its own index?

Usually yes. Separate indexes keep one owner's NDA-covered documents from appearing in another project's answers, and make it simple to archive or delete a project when the contract requires it.

Ready to Modernize Your Business?

Get your AI automation roadmap in minutes, not months.

Analyze Your Workflows →